activerecord-sqlserver-adapter 6.0.1 → 6.1.1.0

data/test/cases/column_test_sqlserver.rb

@@ -157,13 +157,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(col.default).must_equal            BigDecimal("191")
       _(obj.numeric_18_0).must_equal       BigDecimal("191")
       _(col.default_function).must_be_nil
+
       type = connection.lookup_cast_type_from_column(col)
-      _(type).must_be_instance_of Type::Decimal
+      _(type).must_be_instance_of Type::DecimalWithoutScale
       _(type.limit).must_be_nil
       _(type.precision).must_equal         18
-      _(type.scale).must_equal             0
+      _(type.scale).must_be_nil
+
       obj.numeric_18_0 = "192.1"
       _(obj.numeric_18_0).must_equal BigDecimal("192")
+
       obj.save!
       _(obj.reload.numeric_18_0).must_equal BigDecimal("192")
     end
@@ -296,6 +299,8 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(obj.date).must_equal Date.civil(0001, 4, 1)
       obj.reload
       _(obj.date).must_equal Date.civil(0001, 4, 1)
+      # Can filter by date range
+      _(obj).must_equal obj.class.where(date: obj.date..Date::Infinity.new).first
       # Can keep and return assigned date.
       assert_obj_set_and_save :date, Date.civil(1972, 04, 14)
       # Can accept and cast time objects.
@@ -330,6 +335,8 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       obj.reload
       _(obj.datetime).must_equal time, "Microseconds were <#{obj.datetime.usec}> vs <3000>"
       _(obj).must_equal obj.class.where(datetime: time).first
+      # Can filter by datetime range
+      _(obj).must_equal obj.class.where(datetime: time..DateTime::Infinity.new).first
       # Will cast to true DB value on attribute write, save and return again.
       time = Time.utc 2010, 04, 01, 12, 34, 56, 234567
       time2 = Time.utc 2010, 04, 01, 12, 34, 56, 233000

data/test/cases/disconnected_test_sqlserver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class TestDisconnectedAdapter < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  teardown do
+    return if in_memory_db?
+    db_config = ActiveRecord::Base.connection_db_config
+    ActiveRecord::Base.establish_connection(db_config)
+  end
+
+  test "can't execute procedures while disconnected" do
+    @connection.execute_procedure :sp_tables, "sst_datatypes"
+    @connection.disconnect!
+    assert_raises(ActiveRecord::ConnectionNotEstablished, 'SQL Server client is not connected') do
+      @connection.execute_procedure :sp_tables, "sst_datatypes"
+    end
+  end
+
+  test "can't execute query while disconnected" 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_raises(ActiveRecord::ConnectionNotEstablished, 'SQL Server client is not connected') do
+      @connection.exec_query sql, "TEST", binds
+    end
+  end
+end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -41,4 +41,13 @@ class ExecuteProcedureTestSQLServer < ActiveRecord::TestCase
     date_base = connection.select_value("select GETUTCDATE()")
     assert_equal date_base.change(usec: 0), date_proc.change(usec: 0)
   end
+
+  it 'test deprecation with transaction return when executing procedure' do
+    assert_deprecated do
+      ActiveRecord::Base.transaction do
+        connection.execute_procedure("my_getutcdate")
+        return
+      end
+    end
+  end
 end

data/test/cases/fetch_test_sqlserver.rb

@@ -49,3 +49,21 @@ class FetchTestSqlserver < ActiveRecord::TestCase
     @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/in_clause_test_sqlserver.rb

@@ -33,4 +33,31 @@ class InClauseTestSQLServer < ActiveRecord::TestCase
     assert_includes posts.to_sql, "ORDER BY [authors].[name]"
     assert_equal 8, posts.length
   end
+
+  it "removes ordering from 'not' subqueries" do
+    authors_subquery = Author.where.not(name: ["Mary", "Bob"]).order(:name)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_not_includes posts.to_sql, "ORDER BY [authors].[name]"
+    assert_equal 5, posts.length
+  end
+
+  it "does not remove ordering from 'not' subquery that includes a limit" do
+    authors_subquery = Author.where.not(name: ["Ronan", "Mary", "Bob"]).order(:name).limit(2)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_includes posts.to_sql, "ORDER BY [authors].[name]"
+    assert_equal 5, posts.length
+  end
+
+  it "does not remove ordering from 'not' subquery that includes an offset" do
+    authors_subquery = Author.where.not(name: ["David", "Ronan", "Cian"]).order(:name).offset(1)
+    posts = Post.where(author: authors_subquery)
+
+    assert_includes authors_subquery.to_sql, "ORDER BY [authors].[name]"
+    assert_includes posts.to_sql, "ORDER BY [authors].[name]"
+    assert_equal 3, posts.length
+  end
 end

data/test/cases/lateral_test_sqlserver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/post"
+require "models/author"
+
+class LateralTestSQLServer < ActiveRecord::TestCase
+  fixtures :posts, :authors
+
+  it 'uses OUTER APPLY for OUTER JOIN LATERAL' do
+    post = Arel::Table.new(:posts)
+    author = Arel::Table.new(:authors)
+    subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
+
+    one = Arel::Nodes::Quoted.new(1)
+    eq = Arel::Nodes::Equality.new(one, one)
+
+    sql = author.project(Arel.star).where(author[:name].matches("David")).outer_join(subselect.lateral.as("bar")).on(eq).to_sql
+    results = ActiveRecord::Base.connection.exec_query sql
+    assert_equal sql, "SELECT * FROM [authors] OUTER APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
+    assert_equal results.length, 1
+  end
+
+  it 'uses CROSS APPLY for INNER JOIN LATERAL' do
+    post = Arel::Table.new(:posts)
+    author = Arel::Table.new(:authors)
+    subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
+
+    sql = author.project(Arel.star).where(author[:name].matches("David")).join(subselect.lateral.as("bar")).to_sql
+    results = ActiveRecord::Base.connection.exec_query sql
+
+    assert_equal sql, "SELECT * FROM [authors] CROSS APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
+    assert_equal results.length, 0
+  end
+end

data/test/cases/migration_test_sqlserver.rb

@@ -63,5 +63,56 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
     it "change null and default" do
       assert_nothing_raised { connection.change_column :people, :first_name, :text, null: true, default: nil }
     end
+
+    it "change collation" do
+      assert_nothing_raised { connection.change_column :sst_string_collation, :string_with_collation, :varchar, collation: :SQL_Latin1_General_CP437_BIN }
+
+      SstStringCollation.reset_column_information
+      assert_equal "SQL_Latin1_General_CP437_BIN", SstStringCollation.columns_hash['string_with_collation'].collation
+    end
+  end
+
+  describe "#create_schema" do
+    it "creates a new schema" do
+      connection.create_schema("some schema")
+
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema" }
+    end
+
+    it "creates a new schema with an owner" do
+      connection.create_schema("some schema", :guest)
+
+      schemas = connection.exec_query("select name, principal_id from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema", "principal_id" => 2 }
+    end
+  end
+
+  describe "#change_table_schema" do
+    before { connection.create_schema("foo") }
+
+    it "transfer the given table to the given schema" do
+      connection.change_table_schema("foo", "orders")
+
+      assert connection.data_source_exists?("foo.orders")
+    end
+  end
+
+  describe "#drop_schema" do
+    before { connection.create_schema("some schema") }
+
+    it "drops a schema" do
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema" }
+
+      connection.drop_schema("some schema")
+
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      refute_includes schemas, { "name" => "some schema" }
+    end
   end
 end

data/test/cases/optimizer_hints_test_sqlserver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/company"
+
+class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
+  fixtures :companies
+
+  it "apply optimizations" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("HASH GROUP")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Hash Match | Aggregate  |"
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(ORDER GROUP\)\z}) do
+      companies = Company.optimizer_hints("ORDER GROUP")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Stream Aggregate | Aggregate  |"
+    end
+  end
+
+  it "apply multiple optimizations" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP, FAST 1\)\z}) do
+      companies = Company.optimizer_hints("HASH GROUP", "FAST 1")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Hash Match | Flow Distinct |"
+    end
+  end
+
+  it "support subqueries" do
+    assert_sql(%r{.*'SELECT COUNT\(count_column\) FROM \(SELECT .*\) subquery_for_count OPTION \(MAXDOP 2\)'.*}) do
+      companies = Company.optimizer_hints("MAXDOP 2")
+      companies = companies.select(:id).where(firm_id: [0, 1]).limit(3)
+      assert_equal 3, companies.count
+    end
+  end
+
+  it "sanitize values" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("OPTION (HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("OPTION(HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(TABLE HINT \(\[companies\], INDEX\(1\)\)\)\z}) do
+      companies = Company.optimizer_hints("OPTION(TABLE HINT ([companies], INDEX(1)))")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("Option(HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+  end
+
+  it "skip optimization after unscope" do
+    assert_sql("SELECT DISTINCT [companies].[firm_id] FROM [companies]") do
+      companies = Company.optimizer_hints("HASH GROUP")
+      companies = companies.distinct.select("firm_id")
+      companies.unscope(:optimizer_hints).load
+    end
+  end
+end

data/test/cases/order_test_sqlserver.rb

@@ -143,4 +143,11 @@ class OrderTestSQLServer < ActiveRecord::TestCase
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
+
+  # Executing this kind of queries will raise "A column has been specified more than once in the order by list"
+  # This test shows that we don't do anything to prevent this
+  it "doesn't deduplicate semantically equal orders" do
+    sql = Post.order(:id).order("posts.id ASC").to_sql
+    assert_equal "SELECT [posts].* FROM [posts] ORDER BY [posts].[id] ASC, posts.id ASC", sql
+  end
 end

data/test/cases/primary_keys_test_sqlserver.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "support/schema_dumping_helper"
+
+class PrimaryKeyUuidTypeTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  self.use_transactional_tests = false
+
+  class Barcode < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table(:barcodes, primary_key: "code", id: :uuid, force: true)
+  end
+
+  teardown do
+    @connection.drop_table(:barcodes, if_exists: true)
+  end
+
+  def test_any_type_primary_key
+    assert_equal "code", Barcode.primary_key
+
+    column = Barcode.column_for_attribute(Barcode.primary_key)
+    assert_not column.null
+    assert_equal :uuid, column.type
+    assert_not_predicate column, :is_identity?
+    assert_predicate column, :is_primary?
+  ensure
+    Barcode.reset_column_information
+  end
+
+  test "schema dump primary key includes default" do
+    schema = dump_table_schema "barcodes"
+    assert_match %r/create_table "barcodes", primary_key: "code", id: :uuid, default: -> { "newid\(\)" }/, schema
+  end
+end
+
+class PrimaryKeyIntegerTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  self.use_transactional_tests = false
+
+  class Barcode < ActiveRecord::Base
+  end
+
+  class Widget < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+  end
+
+  teardown do
+    @connection.drop_table :barcodes, if_exists: true
+    @connection.drop_table :widgets, if_exists: true
+  end
+
+  test "integer primary key without default" do
+    @connection.create_table(:widgets, id: :integer, force: true)
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_predicate column, :is_identity?
+    assert_equal :integer, column.type
+    assert_not_predicate column, :bigint?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", id: :integer, force: :cascade do/, schema
+  end
+
+  test "bigint primary key without default" do
+    @connection.create_table(:widgets, id: :bigint, force: true)
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_predicate column, :is_identity?
+    assert_equal :integer, column.type
+    assert_predicate column, :bigint?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", force: :cascade do/, schema
+  end
+
+  test "don't set identity to integer and bigint when there is a default" do
+    @connection.create_table(:barcodes, id: :integer, default: nil, force: true)
+    @connection.create_table(:widgets, id: :bigint, default: nil, force: true)
+
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_not_predicate column, :is_identity?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", id: :bigint, default: nil, force: :cascade do/, schema
+
+    column = @connection.columns(:barcodes).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_not_predicate column, :is_identity?
+
+    schema = dump_table_schema "barcodes"
+    assert_match %r/create_table "barcodes", id: :integer, default: nil, force: :cascade do/, schema
+  end
+end

data/test/cases/rake_test_sqlserver.rb

@@ -10,8 +10,9 @@ class SQLServerRakeTest < ActiveRecord::TestCase
 
   let(:db_tasks)              { ActiveRecord::Tasks::DatabaseTasks }
   let(:new_database)          { "activerecord_unittest_tasks" }
-  let(:default_configuration) { ARTest.connection_config["arunit"] }
+  let(:default_configuration) { ARTest.test_configuration_hashes["arunit"] }
   let(:configuration)         { default_configuration.merge("database" => new_database) }
+  let(:db_config)             { ActiveRecord::Base.configurations.resolve(configuration) }
 
   before { skip "on azure" if azure_skip }
   before { disconnect! unless azure_skip }
@@ -151,7 +152,42 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
     _(filedata).must_match %r{CREATE TABLE dbo\.users}
     db_tasks.purge(configuration)
     _(connection.tables).wont_include "users"
-    db_tasks.load_schema configuration, :sql, filename
+    db_tasks.load_schema db_config, :sql, filename
     _(connection.tables).must_include "users"
   end
 end
+
+class SQLServerRakeSchemaCacheDumpLoadTest < SQLServerRakeTest
+  let(:filename) { File.join ARTest::SQLServer.test_root_sqlserver, "schema_cache.yml" }
+  let(:filedata) { File.read(filename) }
+
+  before do
+    quietly { db_tasks.create(configuration) }
+
+    connection.create_table :users, force: true do |t|
+      t.string :name, null: false
+    end
+  end
+
+  after do
+    FileUtils.rm_rf(filename)
+  end
+
+  it "dumps schema cache with SQL Server metadata" do
+    quietly { db_tasks.dump_schema_cache connection, filename }
+
+    schema_cache = YAML.load(File.read(filename))
+
+    col_id, col_name = connection.schema_cache.columns("users")
+
+    assert col_id.is_identity
+    assert col_id.is_primary
+    assert_equal col_id.ordinal_position, 1
+    assert_equal col_id.table_name, "users"
+
+    assert_not col_name.is_identity
+    assert_not col_name.is_primary
+    assert_equal col_name.ordinal_position, 2
+    assert_equal col_name.table_name, "users"
+  end
+end