activerecord-sqlserver-adapter 6.0.1 → 6.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a7160737c2d7b0946054cdf6e9fd7c26144cef8f1bc66be90d0b51b7e9ba91f
-  data.tar.gz: 67ef07c9e35bd3f4735bed2303f3c63f58d09e1bacb7203339b365457c03d296
+  metadata.gz: c6cf80abcc5b46383279819d86c83c095b5aabcf4969e84bdb2ca3e101777b3a
+  data.tar.gz: e11e7d40bba8a4ce3c2d47e08002c5321f82c25b91fde75caa0f01b37a7f6e70
 SHA512:
-  metadata.gz: 599f09313bdd68db576bd7282174f04ac9c7e848b2d84b73857e5da9ca5a76427bd22a63bc717e90cd7293747701bdcbcbbc4159e7309bd5328a8be8baa5a245
-  data.tar.gz: dd54538736ba65dd12ee1ce87aae3da4e324888ca3a9b7a793cae34817451f66ec5b19e0e67882335057e7136f55f1871dad89553f8dfca0824ecdd6c4f34540
+  metadata.gz: b6f04caed7f5cc895fc185e8976d306901dc0563152b8867f40be0319f8572099495ef27bc205aad7733c8aac0e4baf451769cdc46719c2db248f50a802be324
+  data.tar.gz: 3c8f05837c093f0d44909d1a26bbc97010f8dc5ab07cd5d48bba94d09624c5fe2e5f21488915931c528207eb726860ae0d59b8ca229f353efe0846ff16f7a955

data/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    name: Run test suite
+    runs-on: ubuntu-latest
+
+    env:
+      COMPOSE_FILE: docker-compose.ci.yml
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.5.9, 2.6.7, 2.7.3, 3.0.1]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Build docker images
+        run: docker-compose build --build-arg TARGET_VERSION=${{ matrix.ruby }}
+
+      - name: Run tests
+        run: docker-compose run ci

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## v6.0.2
+
+#### Fixed
+
+- [#858](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/858) Allow table existence to be tested across database schemas.
+
+#### Changed
+
+- [#852](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/852) Updated the column name matchers to accept database and owner names
+
+#### Added
+
+- [#855](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/855) Add helpers to create/change/drop a schema.
+- [#857](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/857) Included WAITFOR as read query type.
+- [#865](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/865) Implemented optimizer hints.
+- [#845](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/845) Add support for lateral using CROSS/OUTER APPLY.
+- [#870](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/870) Added DecimalWithoutScale type
+
 ## v6.0.1
 
 #### Fixed

data/README.md

@@ -1,6 +1,6 @@
 # ActiveRecord SQL Server Adapter. For SQL Server 2012 And Higher.
 
-* [![TravisCI](https://travis-ci.org/rails-sqlserver/activerecord-sqlserver-adapter.svg?branch=master)](https://travis-ci.org/rails-sqlserver/activerecord-sqlserver-adapter) - TravisCI
+* [![CI](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/actions/workflows/ci.yml/badge.svg)](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/actions/workflows/ci.yml) - CI
 * [![Build Status](https://ci.appveyor.com/api/projects/status/mtgbx8f57vr7k2qa/branch/master?svg=true)](https://ci.appveyor.com/project/rails-sqlserver/activerecord-sqlserver-adapter/branch/master) - Appveyor
 * [![Gem Version](http://img.shields.io/gem/v/activerecord-sqlserver-adapter.svg)](https://rubygems.org/gems/activerecord-sqlserver-adapter) - Gem Version
 * [![Gitter chat](https://img.shields.io/badge/%E2%8A%AA%20GITTER%20-JOIN%20CHAT%20%E2%86%92-brightgreen.svg?style=flat)](https://gitter.im/rails-sqlserver/activerecord-sqlserver-adapter) - Community
@@ -52,6 +52,24 @@ Depending on your user and schema setup, it may be needed to use a table name pr
 ActiveRecord::Base.table_name_prefix = 'dbo.'
 ```
 
+It's also possible to create/change/drop a schema in the migration file as in the example below:
+
+```ruby
+class CreateFooSchema < ActiveRecord::Migration[6.0]
+  def up
+    create_schema('foo')
+
+    # Or you could move a table to a different schema
+
+    change_table_schema('foo', 'dbo.admin')
+  end
+
+  def down
+    drop_schema('foo')
+  end
+end
+```
+
 
 #### Configure Connection & App Name
 

data/RUNNING_UNIT_TESTS.md

@@ -5,7 +5,7 @@ This process is much easier than it has been before!
 
 ## MS SQL SERVER
 
-If you don't have easy access to MS SQL Server, you can set up a Vagrant/VirtualBox virtual machine with MS SQL Server. [Here's how](/https://github.com/rails-sqlserver/activerecord-sqlserver-adapter-dev-box).
+If you don't have easy access to MS SQL Server, you can set up a Vagrant/VirtualBox virtual machine with MS SQL Server. [Here's how](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter-dev-box).
 
 ## TL;DR
 

data/VERSION

@@ -1 +1 @@
-6.0.1
+6.0.2

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module DatabaseStatements
-        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :dbcc, :explain, :save, :select, :set, :rollback) # :nodoc:
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :dbcc, :explain, :save, :select, :set, :rollback, :waitfor) # :nodoc:
         private_constant :READ_QUERY
 
         def write_query?(sql) # :nodoc:

data/lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -83,8 +83,8 @@ module ActiveRecord
           \A
           (
             (?:
-              # [table_name].[column_name] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+              # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
+              ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
             )
             (?:\s+AS\s+(?:\w+|\[\w+\]))?
           )
@@ -96,8 +96,8 @@ module ActiveRecord
           \A
           (
             (?:
-              # [table_name].[column_name] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+              # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
+              ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
             )
             (?:\s+ASC|\s+DESC)?
             (?:\s+NULLS\s+(?:FIRST|LAST))?

data/lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -281,14 +281,33 @@ module ActiveRecord
           SQLServer::SchemaDumper.create(self, options)
         end
 
+        def create_schema(schema_name, authorization = nil)
+          sql = "CREATE SCHEMA [#{schema_name}]"
+          sql += " AUTHORIZATION [#{authorization}]" if authorization
+
+          execute sql
+        end
+
+        def change_table_schema(schema_name, table_name)
+          execute "ALTER SCHEMA [#{schema_name}] TRANSFER [#{table_name}]"
+        end
+
+        def drop_schema(schema_name)
+          execute "DROP SCHEMA [#{schema_name}]"
+        end
+
         private
 
         def data_source_sql(name = nil, type: nil)
           scope = quoted_scope name, type: type
-          table_name = lowercase_schema_reflection_sql "TABLE_NAME"
+
+          table_name = lowercase_schema_reflection_sql 'TABLE_NAME'
+          database = scope[:database].present? ? "#{scope[:database]}." : ""
+          table_catalog = scope[:database].present? ? quote(scope[:database]) : "DB_NAME()"
+
           sql = "SELECT #{table_name}"
-          sql += " FROM INFORMATION_SCHEMA.TABLES WITH (NOLOCK)"
-          sql += " WHERE TABLE_CATALOG = DB_NAME()"
+          sql += " FROM #{database}INFORMATION_SCHEMA.TABLES WITH (NOLOCK)"
+          sql += " WHERE TABLE_CATALOG = #{table_catalog}"
           sql += " AND TABLE_SCHEMA = #{quote(scope[:schema])}"
           sql += " AND TABLE_NAME = #{quote(scope[:name])}" if scope[:name]
           sql += " AND TABLE_TYPE = #{quote(scope[:type])}" if scope[:type]
@@ -299,6 +318,7 @@ module ActiveRecord
         def quoted_scope(name = nil, type: nil)
           identifier = SQLServer::Utils.extract_identifiers(name)
           {}.tap do |scope|
+            scope[:database] = identifier.database if identifier.database
             scope[:schema] = identifier.schema || "dbo"
             scope[:name] = identifier.object if identifier.object
             scope[:type] = type if type

data/lib/active_record/connection_adapters/sqlserver/type.rb

@@ -11,6 +11,7 @@ require "active_record/connection_adapters/sqlserver/type/small_integer"
 require "active_record/connection_adapters/sqlserver/type/tiny_integer"
 require "active_record/connection_adapters/sqlserver/type/boolean"
 require "active_record/connection_adapters/sqlserver/type/decimal"
+require "active_record/connection_adapters/sqlserver/type/decimal_without_scale"
 require "active_record/connection_adapters/sqlserver/type/money"
 require "active_record/connection_adapters/sqlserver/type/small_money"
 # Approximate Numerics

data/lib/active_record/connection_adapters/sqlserver/type/decimal_without_scale.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module Type
+        class DecimalWithoutScale < ActiveRecord::Type::DecimalWithoutScale
+          def sqlserver_type
+            "decimal".yield_self do |type|
+              type += "(#{precision.to_i},0)" if precision
+              type
+            end
+          end
+
+          def type_cast_for_schema(value)
+            value.is_a?(BigDecimal) ? value.to_s : value.inspect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -152,6 +152,10 @@ module ActiveRecord
         true
       end
 
+      def supports_optimizer_hints?
+        true
+      end
+
       def supports_lazy_transactions?
         true
       end
@@ -296,6 +300,7 @@ module ActiveRecord
 
       def initialize_type_map(m = type_map)
         m.register_type              %r{.*}, SQLServer::Type::UnicodeString.new
+
         # Exact Numerics
         register_class_with_limit m, "bigint(8)",         SQLServer::Type::BigInteger
         m.alias_type                 "bigint",            "bigint(8)"
@@ -308,16 +313,22 @@ module ActiveRecord
         m.alias_type                 "tinyint",           "tinyint(1)"
         m.register_type              "bit",               SQLServer::Type::Boolean.new
         m.register_type              %r{\Adecimal}i do |sql_type|
-          scale = extract_scale(sql_type)
+          scale     = extract_scale(sql_type)
           precision = extract_precision(sql_type)
-          SQLServer::Type::Decimal.new precision: precision, scale: scale
+          if scale == 0
+            SQLServer::Type::DecimalWithoutScale.new(precision: precision)
+          else
+            SQLServer::Type::Decimal.new(precision: precision, scale: scale)
+          end
         end
         m.alias_type                 %r{\Anumeric}i,      "decimal"
         m.register_type              "money",             SQLServer::Type::Money.new
         m.register_type              "smallmoney",        SQLServer::Type::SmallMoney.new
+
         # Approximate Numerics
         m.register_type              "float",             SQLServer::Type::Float.new
         m.register_type              "real",              SQLServer::Type::Real.new
+
         # Date and Time
         m.register_type              "date",              SQLServer::Type::Date.new
         m.register_type              %r{\Adatetime} do |sql_type|
@@ -337,11 +348,13 @@ module ActiveRecord
           precision = extract_precision(sql_type) || DEFAULT_TIME_PRECISION
           SQLServer::Type::Time.new precision: precision
         end
+
         # Character Strings
         register_class_with_limit m, %r{\Achar}i,         SQLServer::Type::Char
         register_class_with_limit m, %r{\Avarchar}i,      SQLServer::Type::Varchar
         m.register_type              "varchar(max)",      SQLServer::Type::VarcharMax.new
         m.register_type              "text",              SQLServer::Type::Text.new
+
         # Unicode Character Strings
         register_class_with_limit m, %r{\Anchar}i,        SQLServer::Type::UnicodeChar
         register_class_with_limit m, %r{\Anvarchar}i,     SQLServer::Type::UnicodeVarchar
@@ -349,10 +362,12 @@ module ActiveRecord
         m.register_type              "nvarchar(max)",     SQLServer::Type::UnicodeVarcharMax.new
         m.register_type              "nvarchar(max)",     SQLServer::Type::UnicodeVarcharMax.new
         m.register_type              "ntext",             SQLServer::Type::UnicodeText.new
+
         # Binary Strings
         register_class_with_limit m, %r{\Abinary}i,       SQLServer::Type::Binary
         register_class_with_limit m, %r{\Avarbinary}i,    SQLServer::Type::Varbinary
         m.register_type              "varbinary(max)",    SQLServer::Type::VarbinaryMax.new
+
         # Other Data Types
         m.register_type              "uniqueidentifier",  SQLServer::Type::Uuid.new
         m.register_type              "timestamp",         SQLServer::Type::Timestamp.new

data/lib/arel/visitors/sqlserver.rb

@@ -80,6 +80,16 @@ module Arel
         @select_statement = nil
       end
 
+      def visit_Arel_Nodes_SelectCore(o, collector)
+        collector = super
+        maybe_visit o.optimizer_hints, collector
+      end
+
+      def visit_Arel_Nodes_OptimizerHints(o, collector)
+        hints = o.expr.map { |v| sanitize_as_option_clause(v) }.join(", ")
+        collector << "OPTION (#{hints})"
+      end
+
       def visit_Arel_Table o, collector
         # Apparently, o.engine.connection can actually be a different adapter
         # than sqlserver. Can be removed if fixed in ActiveRecord. See:
@@ -115,23 +125,33 @@ module Arel
       end
 
       def visit_Arel_Nodes_InnerJoin o, collector
-        collector << "INNER JOIN "
-        collector = visit o.left, collector
-        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
-        if o.right
-          collector << " "
-          visit(o.right, collector)
+        if o.left.is_a?(Arel::Nodes::As) && o.left.left.is_a?(Arel::Nodes::Lateral)
+          collector << "CROSS "
+          visit o.left, collector
         else
-          collector
+          collector << "INNER JOIN "
+          collector = visit o.left, collector
+          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
+          if o.right
+            collector << " "
+            visit(o.right, collector)
+          else
+            collector
+          end
         end
       end
 
       def visit_Arel_Nodes_OuterJoin o, collector
-        collector << "LEFT OUTER JOIN "
-        collector = visit o.left, collector
-        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
-        collector << " "
-        visit o.right, collector
+        if o.left.is_a?(Arel::Nodes::As) && o.left.left.is_a?(Arel::Nodes::Lateral)
+          collector << "OUTER "
+          visit o.left, collector
+        else
+          collector << "LEFT OUTER JOIN "
+          collector = visit o.left, collector
+          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
+          collector << " "
+          visit o.right, collector
+        end
       end
 
       def collect_in_clause(left, right, collector)
@@ -144,6 +164,10 @@ module Arel
         super
       end
 
+      def collect_optimizer_hints(o, collector)
+        collector
+      end
+
       # SQLServer ToSql/Visitor (Additions)
 
       def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
@@ -174,6 +198,18 @@ module Arel
         collector
       end
 
+      def visit_Arel_Nodes_Lateral o, collector
+        collector << "APPLY"
+        collector << " "
+        if o.expr.is_a?(Arel::Nodes::SelectStatement)
+          collector << "("
+          visit(o.expr, collector)
+          collector << ")"
+        else
+          visit(o.expr, collector)
+        end
+      end
+
       # SQLServer Helpers
 
       def node_value(node)
@@ -247,6 +283,10 @@ module Arel
 
         node.orders = [] unless node.offset || node.limit
       end
+
+      def sanitize_as_option_clause(value)
+        value.gsub(%r{OPTION \s* \( (.+) \)}xi, "\\1")
+      end
     end
   end
 end

data/test/cases/adapter_test_sqlserver.rb

@@ -6,6 +6,7 @@ require "models/task"
 require "models/post"
 require "models/subscriber"
 require "models/minimalistic"
+require "models/college"
 
 class AdapterTestSQLServer < ActiveRecord::TestCase
   fixtures :tasks
@@ -42,17 +43,48 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     assert connection.supports_ddl_transactions?
   end
 
-  it "allow owner table name prefixs like dbo to still allow table exists to return true" do
+  it "table exists works if table name prefixed by schema and owner" do
     begin
       assert_equal "topics", Topic.table_name
       assert Topic.table_exists?
+
+      # Test when owner included in table name.
       Topic.table_name = "dbo.topics"
-      assert Topic.table_exists?, "Tasks table name of dbo.topics should return true for exists."
+      assert Topic.table_exists?, "Topics table name of 'dbo.topics' should return true for exists."
+
+      # Test when database and owner included in table name.
+      Topic.table_name = "#{ActiveRecord::Base.configurations["arunit"]['database']}.dbo.topics"
+      assert Topic.table_exists?, "Topics table name of '[DATABASE].dbo.topics' should return true for exists."
     ensure
       Topic.table_name = "topics"
     end
   end
 
+  it "test table existence across database schemas" do
+    arunit_connection = Topic.connection
+    arunit2_connection = College.connection
+
+    arunit_database = arunit_connection.pool.spec.config[:database]
+    arunit2_database = arunit2_connection.pool.spec.config[:database]
+
+    # Assert that connections use different default databases schemas.
+    assert_not_equal arunit_database, arunit2_database
+
+    # Assert that the Topics table exists when using the Topics connection.
+    assert arunit_connection.table_exists?('topics'), 'Topics table exists using table name'
+    assert arunit_connection.table_exists?('dbo.topics'), 'Topics table exists using owner and table name'
+    assert arunit_connection.table_exists?("#{arunit_database}.dbo.topics"), 'Topics table exists using database, owner and table name'
+
+    # Assert that the Colleges table exists when using the Colleges connection.
+    assert arunit2_connection.table_exists?('colleges'), 'College table exists using table name'
+    assert arunit2_connection.table_exists?('dbo.colleges'), 'College table exists using owner and table name'
+    assert arunit2_connection.table_exists?("#{arunit2_database}.dbo.colleges"), 'College table exists using database, owner and table name'
+
+    # Assert that the tables exist when using each others connection.
+    assert arunit_connection.table_exists?("#{arunit2_database}.dbo.colleges"), 'Colleges table exists using Topics connection'
+    assert arunit2_connection.table_exists?("#{arunit_database}.dbo.topics"), 'Topics table exists using Colleges connection'
+  end
+
   it "return true to insert sql query for inserts only" do
     assert connection.send(:insert_sql?, "INSERT...")
     assert connection.send(:insert_sql?, "EXEC sp_executesql N'INSERT INTO [fk_test_has_fks] ([fk_id]) VALUES (@0); SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident', N'@0 int', @0 = 0")

data/test/cases/coerced_tests.rb

@@ -396,39 +396,6 @@ module ActiveRecord
 end
 
 class MigrationTest < ActiveRecord::TestCase
-  # We do not have do the DecimalWithoutScale type.
-  coerce_tests! :test_add_table_with_decimals
-  def test_add_table_with_decimals_coerced
-    Person.connection.drop_table :big_numbers rescue nil
-    assert !BigNumber.table_exists?
-    GiveMeBigNumbers.up
-    BigNumber.reset_column_information
-    assert BigNumber.create(
-      :bank_balance => 1586.43,
-      :big_bank_balance => BigDecimal("1000234000567.95"),
-      :world_population => 6000000000,
-      :my_house_population => 3,
-      :value_of_e => BigDecimal("2.7182818284590452353602875")
-    )
-    b = BigNumber.first
-    assert_not_nil b
-    assert_not_nil b.bank_balance
-    assert_not_nil b.big_bank_balance
-    assert_not_nil b.world_population
-    assert_not_nil b.my_house_population
-    assert_not_nil b.value_of_e
-    assert_kind_of BigDecimal, b.world_population
-    assert_equal "6000000000.0", b.world_population.to_s
-    assert_kind_of Integer, b.my_house_population
-    assert_equal 3, b.my_house_population
-    assert_kind_of BigDecimal, b.bank_balance
-    assert_equal BigDecimal("1586.43"), b.bank_balance
-    assert_kind_of BigDecimal, b.big_bank_balance
-    assert_equal BigDecimal("1000234000567.95"), b.big_bank_balance
-    GiveMeBigNumbers.down
-    assert_raise(ActiveRecord::StatementInvalid) { BigNumber.first }
-  end
-
   # For some reason our tests set Rails.@_env which breaks test env switching.
   coerce_tests! :test_internal_metadata_stores_environment_when_other_data_exists
   coerce_tests! :test_internal_metadata_stores_environment
@@ -982,6 +949,21 @@ class RelationTest < ActiveRecord::TestCase
   end
 end
 
+module ActiveRecord
+  class RelationTest < ActiveRecord::TestCase
+    # Skipping this test. SQL Server doesn't support optimizer hint as comments
+    coerce_tests! :test_relation_with_optimizer_hints_filters_sql_comment_delimiters
+
+    coerce_tests! :test_does_not_duplicate_optimizer_hints_on_merge
+    def test_does_not_duplicate_optimizer_hints_on_merge_coerced
+      escaped_table = Post.connection.quote_table_name("posts")
+      expected = "SELECT #{escaped_table}.* FROM #{escaped_table} OPTION (OMGHINT)"
+      query = Post.optimizer_hints("OMGHINT").merge(Post.optimizer_hints("OMGHINT")).to_sql
+      assert_equal expected, query
+    end
+  end
+end
+
 require "models/post"
 class SanitizeTest < ActiveRecord::TestCase
   # Use nvarchar string (N'') in assert
@@ -1243,7 +1225,11 @@ module ActiveRecord
   end
 end
 
+require "models/post"
+require "models/comment"
 class UnsafeRawSqlTest < ActiveRecord::TestCase
+  fixtures :posts
+
   # Use LEN() vs length() function.
   coerce_tests! %r{order: always allows Arel}
   test "order: always allows Arel" do
@@ -1273,6 +1259,86 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
     assert_equal ids_expected, ids_depr
     assert_equal ids_expected, ids_disabled
   end
+
+  test "order: allows string column names that are quoted" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("[id]").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("[id]").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows string column names that are quoted with table" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("[posts].[id]").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("[posts].[id]").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows string column names that are quoted with table and user" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("[dbo].[posts].[id]").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("[dbo].[posts].[id]").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows string column names that are quoted with table, user and database" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("[activerecord_unittest].[dbo].[posts].[id]").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("[activerecord_unittest].[dbo].[posts].[id]").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "pluck: allows string column name that are quoted" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("[title]") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("[title]") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: allows string column name that are quoted with table" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("[posts].[title]") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("[posts].[title]") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: allows string column name that are quoted with table and user" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("[dbo].[posts].[title]") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("[dbo].[posts].[title]") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: allows string column name that are quoted with table, user and database" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("[activerecord_unittest].[dbo].[posts].[title]") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("[activerecord_unittest].[dbo].[posts].[title]") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
 end
 
 class ReservedWordTest < ActiveRecord::TestCase

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

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

@@ -64,4 +64,48 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       assert_nothing_raised { connection.change_column :people, :first_name, :text, null: true, default: nil }
     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/schema_dumper_test_sqlserver.rb

@@ -16,7 +16,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :tinyint,           type: "integer",      limit: 1,             precision: nil,   scale: nil,  default: 42
     assert_line :bit,               type: "boolean",      limit: nil,           precision: nil,   scale: nil,  default: true
     assert_line :decimal_9_2,       type: "decimal",      limit: nil,           precision: 9,     scale: 2,    default: 12345.01
-    assert_line :numeric_18_0,      type: "decimal",      limit: nil,           precision: 18,    scale: 0,    default: 191.0
+    assert_line :numeric_18_0,      type: "decimal",      limit: nil,           precision: 18,    scale: nil,  default: 191
     assert_line :numeric_36_2,      type: "decimal",      limit: nil,           precision: 36,    scale: 2,    default: 12345678901234567890.01
     assert_line :money,             type: "money",        limit: nil,           precision: 19,    scale: 4,    default: 4.2
     assert_line :smallmoney,        type: "smallmoney",   limit: nil,           precision: 10,    scale: 4,    default: 4.2
@@ -75,7 +75,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :integer_col,     type: "integer",      limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :bigint_col,      type: "bigint",       limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :boolean_col,     type: "boolean",      limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :decimal_col,     type: "decimal",      limit: nil,          precision: 18,   scale: 0,   default: nil
+    assert_line :decimal_col,     type: "decimal",      limit: nil,          precision: 18,   scale: nil, default: nil
     assert_line :float_col,       type: "float",        limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :string_col,      type: "string",       limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :text_col,        type: "text",         limit: nil,          precision: nil,  scale: nil, default: nil
@@ -166,13 +166,15 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   def assert_line(column_name, options = {})
     line = line(column_name)
-    assert line, "Count not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
+    assert line, "Could not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
+
     [:type, :limit, :precision, :scale, :collation, :default].each do |key|
       next unless options.key?(key)
 
       actual   = key == :type ? line.send(:type_method) : line.send(key)
       expected = options[key]
       message  = "#{key.to_s.titleize} of #{expected.inspect} not found in:\n#{line}"
+
       if expected.nil?
         _(actual).must_be_nil message
       elsif expected.is_a?(Array)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version
-  version: 6.0.1
+  version: 6.0.2
 platform: ruby
 authors:
 - Ken Collins
@@ -14,7 +14,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-16 00:00:00.000000000 Z
+date: 2021-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -54,9 +54,9 @@ extra_rdoc_files: []
 files:
 - ".editorconfig"
 - ".github/issue_template.md"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Dockerfile.ci
@@ -104,6 +104,7 @@ files:
 - lib/active_record/connection_adapters/sqlserver/type/datetime2.rb
 - lib/active_record/connection_adapters/sqlserver/type/datetimeoffset.rb
 - lib/active_record/connection_adapters/sqlserver/type/decimal.rb
+- lib/active_record/connection_adapters/sqlserver/type/decimal_without_scale.rb
 - lib/active_record/connection_adapters/sqlserver/type/float.rb
 - lib/active_record/connection_adapters/sqlserver/type/integer.rb
 - lib/active_record/connection_adapters/sqlserver/type/json.rb
@@ -154,7 +155,9 @@ files:
 - test/cases/in_clause_test_sqlserver.rb
 - test/cases/index_test_sqlserver.rb
 - test/cases/json_test_sqlserver.rb
+- test/cases/lateral_test_sqlserver.rb
 - test/cases/migration_test_sqlserver.rb
+- test/cases/optimizer_hints_test_sqlserver.rb
 - test/cases/order_test_sqlserver.rb
 - test/cases/pessimistic_locking_test_sqlserver.rb
 - test/cases/rake_test_sqlserver.rb
@@ -214,8 +217,8 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues
-  changelog_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v6.0.1/CHANGELOG.md
-  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v6.0.1
+  changelog_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v6.0.2/CHANGELOG.md
+  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v6.0.2
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -231,7 +234,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: ActiveRecord SQL Server Adapter.
@@ -253,7 +256,9 @@ test_files:
 - test/cases/in_clause_test_sqlserver.rb
 - test/cases/index_test_sqlserver.rb
 - test/cases/json_test_sqlserver.rb
+- test/cases/lateral_test_sqlserver.rb
 - test/cases/migration_test_sqlserver.rb
+- test/cases/optimizer_hints_test_sqlserver.rb
 - test/cases/order_test_sqlserver.rb
 - test/cases/pessimistic_locking_test_sqlserver.rb
 - test/cases/rake_test_sqlserver.rb

data/.travis.yml

@@ -1,23 +0,0 @@
-sudo: required
-cache: bundler
-services:
-  - docker
-env:
-  global:
-    - COMPOSE_FILE: docker-compose.ci.yml
-before_install:
-  - sudo rm /usr/local/bin/docker-compose
-  - sudo curl -L "https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
-  - sudo chmod +x /usr/local/bin/docker-compose
-install:
-  - docker-compose build --build-arg TARGET_VERSION=$TARGET_VERSION
-script:
-  - docker-compose run ci
-matrix:
-  include:
-    - name: 2.5.8
-      env: TARGET_VERSION=2.5.8
-    - name: 2.6.6
-      env: TARGET_VERSION=2.6.6
-    - name: 2.7.1
-      env: TARGET_VERSION=2.7.1