activerecord-sqlserver-adapter 5.2.1 → 7.0.0.0

data/lib/active_record/sqlserver_base.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionHandling
     def sqlserver_connection(config) #:nodoc:
       config = config.symbolize_keys
-      config.reverse_merge! mode: :dblib
-      mode = config[:mode].to_s.downcase.underscore.to_sym
-      case mode
-      when :dblib
-        require 'tiny_tds'
-      else
-        raise ArgumentError, "Unknown connection mode in #{config.inspect}."
-      end
-      ConnectionAdapters::SQLServerAdapter.new(nil, nil, config.merge(mode: mode))
+      config.reverse_merge!(mode: :dblib)
+      config[:mode] = config[:mode].to_s.downcase.underscore.to_sym
+
+      ConnectionAdapters::SQLServerAdapter.new(
+        ConnectionAdapters::SQLServerAdapter.new_client(config),
+        logger,
+        nil,
+        config
+        )
     end
   end
 end

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -1,28 +1,33 @@
-require 'active_record/tasks/database_tasks'
-require 'shellwords'
-require 'ipaddr'
-require 'socket'
+# frozen_string_literal: true
+
+require "active_record/tasks/database_tasks"
+require "shellwords"
+require "ipaddr"
+require "socket"
 
 module ActiveRecord
   module Tasks
-
     class SQLServerDatabaseTasks
-
-      DEFAULT_COLLATION = 'SQL_Latin1_General_CP1_CI_AS'
+      DEFAULT_COLLATION = "SQL_Latin1_General_CP1_CI_AS"
 
       delegate :connection, :establish_connection, :clear_active_connections!,
                to: ActiveRecord::Base
 
+      def self.using_database_configurations?
+        true
+      end
+
       def initialize(configuration)
         @configuration = configuration
+        @configuration_hash = @configuration.configuration_hash
       end
 
       def create(master_established = false)
         establish_master_connection unless master_established
-        connection.create_database configuration['database'], configuration.merge('collation' => default_collation)
+        connection.create_database configuration.database, configuration_hash.merge(collation: default_collation)
         establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        if /database .* already exists/i === error.message
+      rescue ActiveRecord::StatementInvalid => e
+        if /database .* already exists/i === e.message
           raise DatabaseAlreadyExists
         else
           raise
@@ -31,7 +36,7 @@ module ActiveRecord
 
       def drop
         establish_master_connection
-        connection.drop_database configuration['database']
+        connection.drop_database configuration.database
       end
 
       def charset
@@ -49,27 +54,28 @@ module ActiveRecord
       end
 
       def structure_dump(filename, extra_flags)
-        server_arg = "-S #{Shellwords.escape(configuration['host'])}"
-        server_arg += ":#{Shellwords.escape(configuration['port'])}" if configuration['port']
+        server_arg = "-S #{Shellwords.escape(configuration_hash[:host])}"
+        server_arg += ":#{Shellwords.escape(configuration_hash[:port])}" if configuration_hash[:port]
         command = [
           "defncopy-ttds",
           server_arg,
-          "-D #{Shellwords.escape(configuration['database'])}",
-          "-U #{Shellwords.escape(configuration['username'])}",
-          "-P #{Shellwords.escape(configuration['password'])}",
+          "-D #{Shellwords.escape(configuration_hash[:database])}",
+          "-U #{Shellwords.escape(configuration_hash[:username])}",
+          "-P #{Shellwords.escape(configuration_hash[:password])}",
           "-o #{Shellwords.escape(filename)}",
         ]
         table_args = connection.tables.map { |t| Shellwords.escape(t) }
         command.concat(table_args)
         view_args = connection.views.map { |v| Shellwords.escape(v) }
         command.concat(view_args)
-        raise 'Error dumping database' unless Kernel.system(command.join(' '))
+        raise "Error dumping database" unless Kernel.system(command.join(" "))
+
         dump = File.read(filename)
-        dump.gsub!(/^USE .*$\nGO\n/, '')                      # Strip db USE statements
-        dump.gsub!(/^GO\n/, '')                               # Strip db GO statements
-        dump.gsub!(/nvarchar\(8000\)/, 'nvarchar(4000)')      # Fix nvarchar(8000) column defs
-        dump.gsub!(/nvarchar\(-1\)/, 'nvarchar(max)')         # Fix nvarchar(-1) column defs
-        dump.gsub!(/text\(\d+\)/, 'text')                     # Fix text(16) column defs
+        dump.gsub!(/^USE .*$\nGO\n/, "")                      # Strip db USE statements
+        dump.gsub!(/^GO\n/, "")                               # Strip db GO statements
+        dump.gsub!(/nvarchar\(8000\)/, "nvarchar(4000)")      # Fix nvarchar(8000) column defs
+        dump.gsub!(/nvarchar\(-1\)/, "nvarchar(max)")         # Fix nvarchar(-1) column defs
+        dump.gsub!(/text\(\d+\)/, "text")                     # Fix text(16) column defs
         File.open(filename, "w") { |file| file.puts dump }
       end
 
@@ -77,33 +83,27 @@ module ActiveRecord
         connection.execute File.read(filename)
       end
 
-
       private
 
-      def configuration
-        @configuration
-      end
+      attr_reader :configuration, :configuration_hash
 
       def default_collation
-        configuration['collation'] || DEFAULT_COLLATION
+        configuration_hash[:collation] || DEFAULT_COLLATION
       end
 
       def establish_master_connection
-        establish_connection configuration.merge('database' => 'master')
+        establish_connection configuration_hash.merge(database: "master")
       end
-
     end
 
     module DatabaseTasksSQLServer
-
       extend ActiveSupport::Concern
 
       module ClassMethods
-
         LOCAL_IPADDR = [
-          IPAddr.new('192.168.0.0/16'),
-          IPAddr.new('10.0.0.0/8'),
-          IPAddr.new('172.16.0.0/12')
+          IPAddr.new("192.168.0.0/16"),
+          IPAddr.new("10.0.0.0/8"),
+          IPAddr.new("172.16.0.0/12")
         ]
 
         private
@@ -113,21 +113,20 @@ module ActiveRecord
         end
 
         def configuration_host_ip(configuration)
-          return nil unless configuration['host']
-          Socket::getaddrinfo(configuration['host'], 'echo', Socket::AF_INET)[0][3]
+          return nil unless configuration.host
+
+          Socket::getaddrinfo(configuration.host, "echo", Socket::AF_INET)[0][3]
         end
 
         def local_ipaddr?(host_ip)
           return false unless host_ip
+
           LOCAL_IPADDR.any? { |ip| ip.include?(host_ip) }
         end
-
       end
-
     end
 
     DatabaseTasks.register_task %r{sqlserver}, SQLServerDatabaseTasks
     DatabaseTasks.send :include, DatabaseTasksSQLServer
-
   end
 end

data/lib/activerecord-sqlserver-adapter.rb

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

data/lib/arel/visitors/sqlserver.rb

@@ -1,47 +1,54 @@
+# frozen_string_literal: true
+
 module Arel
   module Visitors
     class SQLServer < Arel::Visitors::ToSql
-
       OFFSET = " OFFSET "
       ROWS = " ROWS"
       FETCH = " FETCH NEXT "
       FETCH0 = " FETCH FIRST (SELECT 0) "
       ROWS_ONLY = " ROWS ONLY"
 
-
       private
 
-      # SQLServer ToSql/Visitor (Overides)
+      # SQLServer ToSql/Visitor (Overrides)
 
-      def visit_Arel_Nodes_BindParam o, collector
-        collector.add_bind(o.value) { |i| "@#{i-1}" }
-      end
+      BIND_BLOCK = proc { |i| "@#{i - 1}" }
+      private_constant :BIND_BLOCK
 
-      def visit_Arel_Nodes_Bin o, collector
+      def bind_block; BIND_BLOCK; end
+
+      def visit_Arel_Nodes_Bin(o, collector)
         visit o.expr, collector
         collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
       end
 
-      def visit_Arel_Nodes_UpdateStatement(o, a)
+      def visit_Arel_Nodes_Concat(o, collector)
+        visit o.left, collector
+        collector << " + "
+        visit o.right, collector
+      end
+
+      def visit_Arel_Nodes_UpdateStatement(o, collector)
         if o.orders.any? && o.limit.nil?
           o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
         end
         super
       end
 
-      def visit_Arel_Nodes_Lock o, collector
-        o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
-        collector << SPACE
+      def visit_Arel_Nodes_Lock(o, collector)
+        o.expr = Arel.sql("WITH(UPDLOCK)") if o.expr.to_s =~ /FOR UPDATE/
+        collector << " "
         visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Offset o, collector
+      def visit_Arel_Nodes_Offset(o, collector)
         collector << OFFSET
         visit o.expr, collector
         collector << ROWS
       end
 
-      def visit_Arel_Nodes_Limit o, collector
+      def visit_Arel_Nodes_Limit(o, collector)
         if node_value(o) == 0
           collector << FETCH0
           collector << ROWS_ONLY
@@ -52,14 +59,52 @@ module Arel
         end
       end
 
-      def visit_Arel_Nodes_SelectStatement o, collector
+      def visit_Arel_Nodes_Grouping(o, collector)
+        remove_invalid_ordering_from_select_statement(o.expr)
+        super
+      end
+
+      def visit_Arel_Nodes_HomogeneousIn(o, collector)
+        collector.preparable = false
+
+        collector << quote_table_name(o.table_name) << "." << quote_column_name(o.column_name)
+
+        if o.type == :in
+          collector << " IN ("
+        else
+          collector << " NOT IN ("
+        end
+
+        values = o.casted_values
+
+        if values.empty?
+          collector << @connection.quote(nil)
+        elsif @connection.prepared_statements
+          # Monkey-patch start. Add query attribute bindings rather than just values.
+          column_name = o.column_name
+          column_type = o.attribute.relation.type_for_attribute(o.column_name)
+          # Use cast_type on encrypted attributes. Don't encrypt them again
+          column_type = column_type.cast_type if column_type.is_a?(ActiveRecord::Encryption::EncryptedAttributeType)
+          attrs = values.map { |value| ActiveRecord::Relation::QueryAttribute.new(column_name, value, column_type) }
+
+          collector.add_binds(attrs, &bind_block)
+          # Monkey-patch end.
+        else
+          collector.add_binds(values, &bind_block)
+        end
+
+        collector << ")"
+        collector
+      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|
+        collector = o.cores.inject(collector) { |c, x|
           visit_Arel_Nodes_SelectCore(x, c)
         }
         collector = visit_Orders_And_Let_Fetch_Happen o, collector
@@ -69,19 +114,31 @@ module Arel
         @select_statement = nil
       end
 
-      def visit_Arel_Table o, collector
+      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:
         # github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/450
-        table_name = begin
-          if o.class.engine.connection.respond_to?(:sqlserver?) && o.class.engine.connection.database_prefix_remote_server?
-            remote_server_table_name(o)
-          else
+        table_name =
+          begin
+            if o.class.engine.connection.respond_to?(:sqlserver?) && o.class.engine.connection.database_prefix_remote_server?
+              remote_server_table_name(o)
+            else
+              quote_table_name(o.name)
+            end
+          rescue Exception
             quote_table_name(o.name)
           end
-        rescue Exception => e
-          quote_table_name(o.name)
-        end
+
         if o.table_alias
           collector << "#{table_name} #{quote_table_name o.table_alias}"
         else
@@ -89,73 +146,109 @@ module Arel
         end
       end
 
-      def visit_Arel_Nodes_JoinSource o, collector
+      def visit_Arel_Nodes_JoinSource(o, collector)
         if o.left
           collector = visit o.left, collector
           collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
         end
         if o.right.any?
-          collector << SPACE if o.left
-          collector = inject_join o.right, collector, ' '
+          collector << " " if o.left
+          collector = inject_join o.right, collector, " "
         end
         collector
       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 << SPACE
-          visit(o.right, collector)
+      def visit_Arel_Nodes_InnerJoin(o, 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 << SPACE
-        visit o.right, collector
+      def visit_Arel_Nodes_OuterJoin(o, 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 visit_Arel_Nodes_In(o, collector)
+        if Array === o.right
+          o.right.each { |node| remove_invalid_ordering_from_select_statement(node) }
+        else
+          remove_invalid_ordering_from_select_statement(o.right)
+        end
+
+        super
+      end
+
+      def collect_optimizer_hints(o, collector)
+        collector
       end
 
       # SQLServer ToSql/Visitor (Additions)
 
-      def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
+      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
 
-      def visit_Orders_And_Let_Fetch_Happen o, collector
+      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
       end
 
-      def visit_Make_Fetch_Happen o, collector
+      def visit_Make_Fetch_Happen(o, collector)
         o.offset = Nodes::Offset.new(0) if o.limit && !o.offset
         collector = visit o.offset, collector if o.offset
         collector = visit o.limit, collector if o.limit
         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)
         return nil unless node
+
         case node.expr
         when NilClass then nil
         when Numeric then node.expr
@@ -167,18 +260,20 @@ module Arel
         @select_statement && @select_statement.lock
       end
 
-      def make_Fetch_Possible_And_Deterministic o
+      def make_Fetch_Possible_And_Deterministic(o)
         return if o.limit.nil? && o.offset.nil?
+
         t = table_From_Statement o
         pk = primary_Key_From_Table t
         return unless pk
+
         if o.orders.empty?
           # Prefer deterministic vs a simple `(SELECT NULL)` expr.
           o.orders = [pk.asc]
         end
       end
 
-      def distinct_One_As_One_Is_So_Not_Fetch o
+      def distinct_One_As_One_Is_So_Not_Fetch(o)
         core = o.cores.first
         distinct = Nodes::Distinct === core.set_quantifier
         oneasone = core.projections.all? { |x| x == ActiveRecord::FinderMethods::ONE_AS_ONE }
@@ -189,30 +284,56 @@ module Arel
         end
       end
 
-      def table_From_Statement o
+      def table_From_Statement(o)
         core = o.cores.first
         if Arel::Table === core.from
           core.from
         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
 
-      def primary_Key_From_Table t
+      def primary_Key_From_Table(t)
         return unless t
-        column_name = @connection.schema_cache.primary_keys(t.name) ||
-          @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+
+        primary_keys = @connection.schema_cache.primary_keys(t.name)
+        column_name = nil
+
+        case primary_keys
+        when NilClass
+          column_name = @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+        when String
+          column_name = primary_keys
+        when Array
+          candidate_columns = @connection.schema_cache.columns_hash(t.name).slice(*primary_keys).values
+          candidate_column = candidate_columns.find(&:is_identity?)
+          candidate_column ||= candidate_columns.first
+          column_name = candidate_column.try(:name)
+        end
+
         column_name ? t[column_name] : nil
       end
 
-      def remote_server_table_name o
+      def remote_server_table_name(o)
         ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
           "#{o.class.engine.connection.database_prefix}#{o.name}"
         ).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
+
+      def sanitize_as_option_clause(value)
+        value.gsub(%r{OPTION \s* \( (.+) \)}xi, "\\1")
+      end
     end
   end
 end

data/lib/arel_sqlserver.rb

@@ -1,2 +1,4 @@
-require 'arel'
-require 'arel/visitors/sqlserver'
+# 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/active_schema_test_sqlserver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class ActiveSchemaTestSQLServer < ActiveRecord::TestCase
+  before do
+    connection.create_table :schema_test_table, force: true, id: false do |t|
+      t.column :foo, :string, limit: 100
+      t.column :state, :string
+    end
+  end
+
+  after do
+    connection.drop_table :schema_test_table rescue nil
+  end
+
+  it 'default index' do
+    assert_sql('CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+      connection.add_index :schema_test_table, "foo"
+    end
+  end
+
+  it 'unique index' do
+    assert_sql('CREATE UNIQUE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+      connection.add_index :schema_test_table, "foo", unique: true
+    end
+  end
+
+  it 'where condition on index' do
+    assert_sql("CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo]) WHERE state = 'active'") do
+      connection.add_index :schema_test_table, "foo", where: "state = 'active'"
+    end
+  end
+
+  it 'if index does not exist' do
+    assert_sql("IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = 'index_schema_test_table_on_foo') " \
+               "CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
+      connection.add_index :schema_test_table, "foo", if_not_exists: true
+    end
+  end
+
+  describe "index types" do
+    it 'clustered index' do
+      assert_sql('CREATE CLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo", type: :clustered
+      end
+    end
+
+    it 'nonclustered index' do
+      assert_sql('CREATE NONCLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo", type: :nonclustered
+      end
+    end
+  end
+end