activerecord-sqlserver-adapter-odbc-extended 8.0.10

data/test/cases/connection_test_sqlserver.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+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 '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
+      _(["Fixnum", "Integer"]).must_include connection.spid.class.name
+    end
+
+    it "reset spid on disconnect!" do
+      connection.disconnect!
+      assert connection.spid.nil?
+    end
+
+    it "reset raw connection on disconnect!" do
+      connection.disconnect!
+      _(connection.instance_variable_get(:@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!
+    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/dbconsole.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class DbConsole < ActiveRecord::TestCase
+  subject { ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter }
+
+  it "uses sqlplus to connect to database" do
+    subject.expects(:find_cmd_and_exec).with("sqlcmd", "-d", "db", "-U", "user", "-P", "secret", "-S", "tcp:localhost,1433")
+
+    config = make_db_config(adapter: "sqlserver", database: "db", username: "user", password: "secret", host: "localhost", port: 1433)
+
+    subject.dbconsole(config)
+  end
+
+  private
+
+  def make_db_config(config)
+    ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+  end
+end

data/test/cases/disconnected_test_sqlserver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class TestDisconnectedAdapter < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  undef_method :setup
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  teardown do
+    return if in_memory_db?
+    db_config = ActiveRecord::Base.connection_db_config
+    ActiveRecord::Base.establish_connection(db_config)
+  end
+
+  test "execute procedure after disconnect reconnects" do
+    @connection.execute_procedure :sp_tables, "sst_datatypes"
+    @connection.disconnect!
+
+    assert_nothing_raised do
+      @connection.execute_procedure :sp_tables, "sst_datatypes"
+    end
+  end
+
+  test "execute query after disconnect reconnects" do
+    sql = "SELECT count(*) from products WHERE id IN(@0, @1)"
+    binds = [
+      ActiveRecord::Relation::QueryAttribute.new("id", 2, ActiveRecord::Type::BigInteger.new),
+      ActiveRecord::Relation::QueryAttribute.new("id", 2, ActiveRecord::Type::BigInteger.new)
+    ]
+
+    @connection.exec_query sql, "TEST", binds
+    @connection.disconnect!
+
+    assert_nothing_raised do
+      @connection.exec_query sql, "TEST", binds
+    end
+  end
+end

data/test/cases/eager_load_too_many_ids_test_sqlserver.rb

@@ -0,0 +1,18 @@
+require "cases/helper_sqlserver"
+require "models/citation"
+require "models/book"
+
+class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
+  fixtures :citations
+
+  def test_batch_preloading_too_many_ids
+    in_clause_length = 10_000
+
+    # We Monkey patch Preloader to work with batches of 10_000 records.
+    # Expect: N Books queries + Citation query
+    expected_query_count = (Citation.count / in_clause_length.to_f).ceil + 1
+    assert_queries_count(expected_query_count) do
+      Citation.preload(:reference_of).to_a.size
+    end
+  end
+end

data/test/cases/enum_test_sqlserver.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class EnumTestSQLServer < ActiveRecord::TestCase
+
+  # Check that enums are supported for all string types.
+  # For each type we check: cast, serialize, and update by declaration.
+  # We create a custom class for each type to test.
+  %w[char_10 varchar_50 varchar_max text nchar_10 nvarchar_50 nvarchar_max ntext].each do |col_name|
+    describe "support #{col_name} enums" do
+      let(:klass) do
+        Class.new(ActiveRecord::Base) do
+          self.table_name = 'sst_datatypes'
+
+          enum col_name, { alpha: "A", beta: "B" }
+        end
+      end
+
+      it "type.cast" do
+        type = klass.type_for_attribute(col_name)
+
+        assert_equal "alpha",  type.cast('A')
+        assert_equal "beta",   type.cast('B')
+      end
+
+      it "type.serialize" do
+        type = klass.type_for_attribute(col_name)
+
+        assert_equal 'A', type.serialize('A')
+        assert_equal 'B', type.serialize('B')
+
+        assert_equal 'A', type.serialize(:alpha)
+        assert_equal 'B', type.serialize(:beta)
+      end
+
+      it "update by declaration" do
+        r = klass.new
+
+        r.alpha!
+        assert_predicate r, :alpha?
+
+        r.beta!
+        assert_not_predicate r, :alpha?
+        assert_predicate r, :beta?
+      end
+    end
+  end
+end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+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
+
+  def transaction_with_procedure_and_return
+    ActiveRecord::Base.transaction do
+      connection.execute_procedure("my_getutcdate")
+      return
+    end
+  end
+
+  it 'test deprecation with transaction return when executing procedure' do
+    assert_not_deprecated(ActiveRecord.deprecator) do
+      transaction_with_procedure_and_return
+    end
+  end
+end

data/test/cases/fetch_test_sqlserver.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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
+
+  describe "FROM subquery" do
+    let(:from_sql) { "(SELECT [books].* FROM [books]) [books]" }
+
+    it "SQL generated correctly for FROM subquery if order provided" do
+      query = Book.from(from_sql).order(:id).limit(5)
+
+      assert_equal query.to_sql, "SELECT [books].* FROM (SELECT [books].* FROM [books]) [books] ORDER BY [books].[id] ASC OFFSET 0 ROWS FETCH NEXT 5 ROWS ONLY"
+      assert_equal query.to_a.count, 5
+    end
+
+    it "exception thrown if FROM subquery is provided without an order" do
+      query = Book.from(from_sql).limit(5)
+
+      assert_raise(ActiveRecord::StatementInvalid) do
+        query.to_sql
+      end
+    end
+  end
+
+  protected
+
+  def create_10_books
+    Book.delete_all
+    @books = (1..10).map { |i| Book.create! name: "Name-#{i}" }
+  end
+end
+
+class DeterministicFetchWithCompositePkTestSQLServer < ActiveRecord::TestCase
+  it "orders by the identity column if table has one" do
+    SSCompositePkWithIdentity.delete_all
+    SSCompositePkWithIdentity.create(pk_col_two: 2)
+    SSCompositePkWithIdentity.create(pk_col_two: 1)
+
+    _(SSCompositePkWithIdentity.take(1).map(&:pk_col_two)).must_equal [2]
+  end
+
+  it "orders by the first column if table has no identity column" do
+    SSCompositePkWithoutIdentity.delete_all
+    SSCompositePkWithoutIdentity.create(pk_col_one: 2, pk_col_two: 2)
+    SSCompositePkWithoutIdentity.create(pk_col_one: 1, pk_col_two: 1)
+
+    _(SSCompositePkWithoutIdentity.take(1).map(&:pk_col_two)).must_equal [1]
+  end
+end

data/test/cases/fully_qualified_identifier_test_sqlserver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+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("*")]
+      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,61 @@
+# frozen_string_literal: true
+
+require "support/paths_sqlserver"
+require "bundler/setup"
+Bundler.require :default, :development
+require "pry"
+require "support/core_ext/query_cache"
+require "support/minitest_sqlserver"
+require "support/test_in_memory_oltp"
+require "support/table_definition_sqlserver"
+require "cases/helper"
+require "support/load_schema_sqlserver"
+require "support/coerceable_test_sqlserver"
+require "support/connection_reflection"
+require "support/query_assertions"
+require "mocha/minitest"
+
+module ActiveSupport
+  class TestCase < ::Minitest::Test
+    include ARTest::SQLServer::CoerceableTest
+  end
+end
+
+module ActiveRecord
+  class TestCase < ActiveSupport::TestCase
+    SQLServer = ActiveRecord::ConnectionAdapters::SQLServer
+
+    include ARTest::SQLServer::ConnectionReflection,
+            ActiveSupport::Testing::Stream,
+            ARTest::SQLServer::QueryAssertions
+
+    let(:logger) { ActiveRecord::Base.logger }
+
+    setup :ensure_clean_rails_env
+    setup :remove_backtrace_silencers
+
+    private
+
+    def ensure_clean_rails_env
+      Rails.instance_variable_set(:@_env, nil) if defined?(::Rails)
+    end
+
+    def remove_backtrace_silencers
+      Rails.backtrace_cleaner.remove_silencers!
+    end
+
+    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 }