activerecord-sqlserver-adapter 5.2.1 → 6.0.0.rc1

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Type
         class Varbinary < Binary
 
-          def initialize(*args)
+          def initialize(**args)
             super
             @limit = 8000 if @limit.to_i == 0
           end
@@ -14,8 +16,9 @@ module ActiveRecord
           end
 
           def sqlserver_type
-            'varbinary'.tap do |type|
-              type << "(#{limit})" if limit
+            'varbinary'.yield_self do |type|
+              type += "(#{limit})" if limit
+              type
             end
           end
 

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Type
         class VarbinaryMax < Varbinary
 
-          def initialize(*args)
+          def initialize(**args)
             super
             @limit = 2_147_483_647
           end
@@ -14,7 +16,7 @@ module ActiveRecord
           end
 
           def sqlserver_type
-            'varbinary(max)'.freeze
+            "varbinary(max)"
           end
 
         end

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Type
         class Varchar < Char
 
-          def initialize(*args)
+          def initialize(**args)
             super
             @limit = 8000 if @limit.to_i == 0
           end
@@ -14,8 +16,9 @@ module ActiveRecord
           end
 
           def sqlserver_type
-            'varchar'.tap do |type|
-              type << "(#{limit})" if limit
+            'varchar'.yield_self do |type|
+              type += "(#{limit})" if limit
+              type
             end
           end
 

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Type
         class VarcharMax < Varchar
 
-          def initialize(*args)
+          def initialize(**args)
             super
             @limit = 2_147_483_647
           end
@@ -14,7 +16,7 @@ module ActiveRecord
           end
 
           def sqlserver_type
-            'varchar(max)'.freeze
+            "varchar(max)"
           end
 
         end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'strscan'
 
 module ActiveRecord

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'base64'
 require 'active_record'
 require 'arel_sqlserver'
@@ -9,6 +11,7 @@ require 'active_record/connection_adapters/sqlserver/core_ext/explain_subscriber
 require 'active_record/connection_adapters/sqlserver/core_ext/attribute_methods'
 require 'active_record/connection_adapters/sqlserver/core_ext/finder_methods'
 require 'active_record/connection_adapters/sqlserver/core_ext/query_methods'
+require 'active_record/connection_adapters/sqlserver/core_ext/preloader'
 require 'active_record/connection_adapters/sqlserver/version'
 require 'active_record/connection_adapters/sqlserver/type'
 require 'active_record/connection_adapters/sqlserver/database_limits'
@@ -80,6 +83,12 @@ module ActiveRecord
         SQLServer::SchemaCreation.new self
       end
 
+      def self.database_exists?(config)
+        !!ActiveRecord::Base.sqlserver_connection(config)
+      rescue ActiveRecord::NoDatabaseError
+        false
+      end
+
       def supports_ddl_transactions?
         true
       end
@@ -144,10 +153,30 @@ module ActiveRecord
         true
       end
 
+      def supports_lazy_transactions?
+        true
+      end
+
       def supports_in_memory_oltp?
         @version_year >= 2014
       end
 
+      def supports_insert_returning?
+        true
+      end
+
+      def supports_insert_on_duplicate_skip?
+        false
+      end
+
+      def supports_insert_on_duplicate_update?
+        false
+      end
+
+      def supports_insert_conflict_target?
+        false
+      end
+
       def disable_referential_integrity
         tables = tables_with_referential_integrity
         tables.each { |t| do_execute "ALTER TABLE #{quote_table_name(t)} NOCHECK CONSTRAINT ALL" }
@@ -196,7 +225,7 @@ module ActiveRecord
       # === Abstract Adapter (Misc Support) =========================== #
 
       def tables_with_referential_integrity
-        schemas_and_tables = select_rows <<-SQL.strip_heredoc
+        schemas_and_tables = select_rows <<~SQL.squish
           SELECT DISTINCT s.name, o.name
           FROM sys.foreign_keys i
           INNER JOIN sys.objects o ON i.parent_object_id = o.OBJECT_ID
@@ -256,6 +285,9 @@ module ActiveRecord
         result
       end
 
+      def get_database_version # :nodoc:
+        version_year
+      end
 
       protected
 
@@ -325,18 +357,20 @@ module ActiveRecord
         m.register_type              'timestamp',         SQLServer::Type::Timestamp.new
       end
 
-      def translate_exception(e, message)
+      def translate_exception(e, message:, sql:, binds:)
         case message
         when /(cannot insert duplicate key .* with unique index) | (violation of unique key constraint)/i
-          RecordNotUnique.new(message)
-        when /conflicted with the foreign key constraint/i
-          InvalidForeignKey.new(message)
+          RecordNotUnique.new(message, sql: sql, binds: binds)
+        when /(conflicted with the foreign key constraint) | (The DELETE statement conflicted with the REFERENCE constraint)/i
+          InvalidForeignKey.new(message, sql: sql, binds: binds)
         when /has been chosen as the deadlock victim/i
-          DeadlockVictim.new(message)
+          DeadlockVictim.new(message, sql: sql, binds: binds)
         when /database .* does not exist/i
-          NoDatabaseError.new(message)
+          NoDatabaseError.new(message, sql: sql, binds: binds)
         when /data would be truncated/
-          ValueTooLong.new(message)
+          ValueTooLong.new(message, sql: sql, binds: binds)
+        when /connection timed out/
+          StatementTimeout.new(message, sql: sql, binds: binds)
         when /Column '(.*)' is not the same data type as referencing column '(.*)' in foreign key/
           pk_id, fk_id = SQLServer::Utils.extract_identifiers($1), SQLServer::Utils.extract_identifiers($2)
           MismatchedForeignKey.new(
@@ -348,9 +382,9 @@ module ActiveRecord
             primary_key: pk_id.object
           )
         when /Cannot insert the value NULL into column.*does not allow nulls/
-          NotNullViolation.new(message)
+          NotNullViolation.new(message, sql: sql, binds: binds)
         when /Arithmetic overflow error/
-          RangeError.new(message)
+          RangeError.new(message, sql: sql, binds: binds)
         else
           super
         end

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     class SQLServerColumn < Column
 
-      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
-        @sqlserver_options = sqlserver_options || {}
-        super(name, default, sql_type_metadata, null, table_name, default_function, collation, comment: comment)
+      def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, **sqlserver_options)
+        @sqlserver_options = sqlserver_options
+        super
       end
 
       def is_identity?
@@ -15,6 +17,10 @@ module ActiveRecord
         @sqlserver_options[:is_primary]
       end
 
+      def table_name
+        @sqlserver_options[:table_name]
+      end
+
       def is_utf8?
         sql_type =~ /nvarchar|ntext|nchar/i
       end

data/lib/active_record/sqlserver_base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionHandling
     def sqlserver_connection(config) #:nodoc:
@@ -11,6 +13,12 @@ module ActiveRecord
         raise ArgumentError, "Unknown connection mode in #{config.inspect}."
       end
       ConnectionAdapters::SQLServerAdapter.new(nil, nil, config.merge(mode: mode))
+    rescue TinyTds::Error => e
+      if e.message.match(/database .* does not exist/i)
+        raise ActiveRecord::NoDatabaseError
+      else
+        raise
+      end
     end
   end
 end

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record/tasks/database_tasks'
 require 'shellwords'
 require 'ipaddr'

data/lib/activerecord-sqlserver-adapter.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'active_record/connection_adapters/sqlserver_adapter'

data/lib/arel/visitors/sqlserver.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Arel
   module Visitors
     class SQLServer < Arel::Visitors::ToSql
@@ -22,6 +24,12 @@ module Arel
         collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
       end
 
+      def visit_Arel_Nodes_Concat(o, collector)
+        visit o.left, collector
+        collector << " + "
+        visit o.right, collector
+      end
+
       def visit_Arel_Nodes_UpdateStatement(o, a)
         if o.orders.any? && o.limit.nil?
           o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
@@ -31,7 +39,7 @@ module Arel
 
       def visit_Arel_Nodes_Lock o, collector
         o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
-        collector << SPACE
+        collector << " "
         visit o.expr, collector
       end
 
@@ -52,12 +60,17 @@ module Arel
         end
       end
 
+      def visit_Arel_Nodes_Grouping(o, collector)
+        remove_invalid_ordering_from_select_statement(o.expr)
+        super
+      end
+
       def visit_Arel_Nodes_SelectStatement o, collector
         @select_statement = o
         distinct_One_As_One_Is_So_Not_Fetch o
         if o.with
           collector = visit o.with, collector
-          collector << SPACE
+          collector << " "
         end
         collector = o.cores.inject(collector) { |c,x|
           visit_Arel_Nodes_SelectCore(x, c)
@@ -95,7 +108,7 @@ module Arel
           collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
         end
         if o.right.any?
-          collector << SPACE if o.left
+          collector << " " if o.left
           collector = inject_join o.right, collector, ' '
         end
         collector
@@ -106,7 +119,7 @@ module Arel
         collector = visit o.left, collector
         collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
         if o.right
-          collector << SPACE
+          collector << " "
           visit(o.right, collector)
         else
           collector
@@ -117,16 +130,26 @@ module Arel
         collector << "LEFT OUTER JOIN "
         collector = visit o.left, collector
         collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
-        collector << SPACE
+        collector << " "
         visit o.right, collector
       end
 
+      def collect_in_clause(left, right, collector)
+        if Array === right
+          right.each { |node| remove_invalid_ordering_from_select_statement(node) }
+        else
+          remove_invalid_ordering_from_select_statement(right)
+        end
+
+        super
+      end
+
       # SQLServer ToSql/Visitor (Additions)
 
       def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
         if select_statement_lock?
           collector = visit @select_statement.lock, collector
-          collector << SPACE if options[:space]
+          collector << " " if options[:space]
         end
         collector
       end
@@ -134,12 +157,11 @@ module Arel
       def visit_Orders_And_Let_Fetch_Happen o, collector
         make_Fetch_Possible_And_Deterministic o
         unless o.orders.empty?
-          collector << SPACE
-          collector << ORDER_BY
+          collector << " ORDER BY "
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
             collector = visit(x, collector)
-            collector << COMMA unless len == i
+            collector << ", " unless len == i
           }
         end
         collector
@@ -196,7 +218,7 @@ module Arel
         elsif Arel::Nodes::SqlLiteral === core.from
           Arel::Table.new(core.from)
         elsif Arel::Nodes::JoinSource === core.source
-          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
+          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left.left
         end
       end
 
@@ -213,6 +235,14 @@ module Arel
         ).quoted
       end
 
+      # Need to remove ordering from subqueries unless TOP/OFFSET also used. Otherwise, SQLServer
+      # returns error "The ORDER BY clause is invalid in views, inline functions, derived tables,
+      # subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified."
+      def remove_invalid_ordering_from_select_statement(node)
+        return unless Arel::Nodes::SelectStatement === node
+
+        node.orders = [] unless node.offset || node.limit
+      end
     end
   end
 end

data/lib/arel_sqlserver.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'arel'
 require 'arel/visitors/sqlserver'

data/test/appveyor/dbsetup.ps1

@@ -5,15 +5,15 @@ Write-Output "Setting up..."
 
 Write-Output "Setting variables..."
 $serverName = $env:COMPUTERNAME
-$instances = @('SQL2012SP1', 'SQL2014')
+$instanceNames = @('SQL2014')
 $smo = 'Microsoft.SqlServer.Management.Smo.'
 $wmi = new-object ($smo + 'Wmi.ManagedComputer')
 
 Write-Output "Configure Instances..."
-foreach ($instance in $instances) {
-  Write-Output "Instance $instance ..."
+foreach ($instanceName in $instanceNames) {
+  Write-Output "Instance $instanceName ..."
   Write-Output "Enable TCP/IP and port 1433..."
-  $uri = "ManagedComputer[@Name='$serverName']/ServerInstance[@Name='$instance']/ServerProtocol[@Name='Tcp']"
+  $uri = "ManagedComputer[@Name='$serverName']/ServerInstance[@Name='$instanceName']/ServerProtocol[@Name='Tcp']"
   $tcp = $wmi.GetSmoObject($uri)
   $tcp.IsEnabled = $true
   foreach ($ipAddress in $Tcp.IPAddresses) {

data/test/cases/adapter_test_sqlserver.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cases/helper_sqlserver'
 require 'models/topic'
 require 'models/task'
@@ -13,7 +15,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   let(:basic_update_sql) { "UPDATE [customers] SET [address_street] = NULL WHERE [id] = 2" }
   let(:basic_select_sql) { "SELECT * FROM [customers] WHERE ([customers].[id] = 1)" }
 
-  it 'has basic and non-senstive information in the adpaters inspect method' do
+  it 'has basic and non-sensitive information in the adapters inspect method' do
     string = connection.inspect
     _(string).must_match %r{ActiveRecord::ConnectionAdapters::SQLServerAdapter}
     _(string).must_match %r{version\: \d.\d}
@@ -65,6 +67,25 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     assert_equal 'customers', connection.send(:get_table_name, basic_select_sql)
   end
 
+  it 'test bad connection' do
+    assert_raise ActiveRecord::NoDatabaseError do
+      config = ActiveRecord::Base.configurations['arunit'].merge(database: 'inexistent_activerecord_unittest')
+      ActiveRecord::Base.sqlserver_connection config
+    end
+  end
+
+  it 'test database exists returns false if database does not exist' do
+    config = ActiveRecord::Base.configurations['arunit'].merge(database: 'inexistent_activerecord_unittest')
+    assert_not ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(config),
+                'expected database to not exist'
+  end
+
+  it 'test database exists returns true when the database exists' do
+    config = ActiveRecord::Base.configurations['arunit']
+    assert ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(config),
+            "expected database #{config[:database]} to exist"
+  end
+
   describe 'with different language' do
 
     before do
@@ -429,5 +450,48 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
   end
 
+  describe 'block writes to a database' do
+    def setup
+      @conn = ActiveRecord::Base.connection
+      @connection_handler = ActiveRecord::Base.connection_handler
+    end
+
+    def test_errors_when_an_insert_query_is_called_while_preventing_writes
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @connection_handler.while_preventing_writes do
+          @conn.insert("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
+        end
+      end
+    end
+
+    def test_errors_when_an_update_query_is_called_while_preventing_writes
+      @conn.insert("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
+
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @connection_handler.while_preventing_writes do
+          @conn.update("UPDATE [subscribers] SET [subscribers].[name] = 'Aidan' WHERE [subscribers].[nick] = 'aido'")
+        end
+      end
+    end
+
+    def test_errors_when_a_delete_query_is_called_while_preventing_writes
+      @conn.execute("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
+
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @connection_handler.while_preventing_writes do
+          @conn.execute("DELETE FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
+        end
+      end
+    end
+
+    def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
+      @conn.execute("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
+
+      @connection_handler.while_preventing_writes do
+        assert_equal 1, @conn.execute("SELECT * FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
+      end
+    end
+  end
+
 end