activerecord-sqlserver-adapter 6.0.0.rc1 → 6.1.0.0.rc1

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -3,7 +3,6 @@
 module ActiveRecord
   module ConnectionAdapters
     class SQLServerColumn < Column
-
       def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, **sqlserver_options)
         @sqlserver_options = sqlserver_options
         super
@@ -29,6 +28,22 @@ module ActiveRecord
         collation && collation.match(/_CS/)
       end
 
+      private
+
+      # In the Rails version of this method there is an assumption that the `default` value will always be a
+      # `String` class, which must be true for the MySQL/PostgreSQL/SQLite adapters. However, in the SQL Server
+      # adapter the `default` value can also be Boolean/Date/Time/etc. Changed the implementation of this method
+      # to handle non-String `default` objects.
+      def deduplicated
+        @name = -name
+        @sql_type_metadata = sql_type_metadata.deduplicate if sql_type_metadata
+        @default = (default.is_a?(String) ? -default : default.dup.freeze) if default
+        @default_function = -default_function if default_function
+        @collation = -collation if collation
+        @comment = -comment if comment
+
+        freeze
+      end
     end
   end
 end

data/lib/active_record/sqlserver_base.rb

@@ -4,21 +4,15 @@ 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))
-    rescue TinyTds::Error => e
-      if e.message.match(/database .* does not exist/i)
-        raise ActiveRecord::NoDatabaseError
-      else
-        raise
-      end
+      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,30 +1,33 @@
 # frozen_string_literal: true
 
-require 'active_record/tasks/database_tasks'
-require 'shellwords'
-require 'ipaddr'
-require 'socket'
+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
@@ -33,7 +36,7 @@ module ActiveRecord
 
       def drop
         establish_master_connection
-        connection.drop_database configuration['database']
+        connection.drop_database configuration.database
       end
 
       def charset
@@ -51,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
 
@@ -79,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
@@ -115,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,3 +1,3 @@
 # frozen_string_literal: true
 
-require 'active_record/connection_adapters/sqlserver_adapter'
+require "active_record/connection_adapters/sqlserver_adapter"

data/lib/arel/visitors/sqlserver.rb

@@ -3,23 +3,22 @@
 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
@@ -30,26 +29,26 @@ module Arel
         visit o.right, collector
       end
 
-      def visit_Arel_Nodes_UpdateStatement(o, a)
+      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/
+      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
@@ -65,14 +64,45 @@ module Arel
         super
       end
 
-      def visit_Arel_Nodes_SelectStatement o, collector
+      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)
+          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 << " "
         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
@@ -82,19 +112,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
@@ -102,51 +144,65 @@ 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 << " " if o.left
-          collector = inject_join o.right, collector, ' '
+          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 << " "
-          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 << " "
-        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 collect_in_clause(left, right, collector)
-        if Array === right
-          right.each { |node| remove_invalid_ordering_from_select_statement(node) }
+      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(right)
+          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 << " " if options[:space]
@@ -154,7 +210,7 @@ module Arel
         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 << " ORDER BY "
@@ -167,17 +223,30 @@ module Arel
         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
@@ -189,18 +258,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 }
@@ -211,7 +282,7 @@ 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
@@ -222,14 +293,15 @@ module Arel
         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)
         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
@@ -243,6 +315,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