activerecord-sqlserver-adapter 6.0.1 → 6.1.1.0

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -2,31 +2,87 @@
 
 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
-      end
+    module SQLServer
+      class Column < ConnectionAdapters::Column
+        delegate :is_identity, :is_primary, :table_name, :ordinal_position, to: :sql_type_metadata
 
-      def is_identity?
-        @sqlserver_options[:is_identity]
-      end
+        def initialize(*, is_identity: nil, is_primary: nil, table_name: nil, ordinal_position: nil, **)
+          super
+          @is_identity = is_identity
+          @is_primary = is_primary
+          @table_name = table_name
+          @ordinal_position = ordinal_position
+        end
 
-      def is_primary?
-        @sqlserver_options[:is_primary]
-      end
+        def is_identity?
+          is_identity
+        end
 
-      def table_name
-        @sqlserver_options[:table_name]
-      end
+        def is_primary?
+          is_primary
+        end
 
-      def is_utf8?
-        sql_type =~ /nvarchar|ntext|nchar/i
-      end
+        def is_utf8?
+          sql_type =~ /nvarchar|ntext|nchar/i
+        end
+
+        def case_sensitive?
+          collation && collation.match(/_CS/)
+        end
 
-      def case_sensitive?
-        collation && collation.match(/_CS/)
+        def init_with(coder)
+          @is_identity = coder["is_identity"]
+          @is_primary = coder["is_primary"]
+          @table_name = coder["table_name"]
+          @ordinal_position = coder["ordinal_position"]
+          super
+        end
+
+        def encode_with(coder)
+          coder["is_identity"] = @is_identity
+          coder["is_primary"] = @is_primary
+          coder["table_name"] = @table_name
+          coder["ordinal_position"] = @ordinal_position
+          super
+        end
+
+        def ==(other)
+          other.is_a?(Column) &&
+            super &&
+            is_identity? == other.is_identity? &&
+            is_primary? == other.is_primary? &&
+            table_name == other.table_name &&
+            ordinal_position == other.ordinal_position
+        end
+        alias :eql? :==
+
+        def hash
+          Column.hash ^
+            super.hash ^
+            is_identity?.hash ^
+            is_primary?.hash ^
+            table_name.hash ^
+            ordinal_position.hash
+        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
+
+      SQLServerColumn = SQLServer::Column
     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

@@ -13,13 +13,18 @@ module ActiveRecord
       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 => e
         if /database .* already exists/i === e.message
@@ -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,14 +54,14 @@ 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) }
@@ -80,16 +85,14 @@ module ActiveRecord
 
       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
 
@@ -110,9 +113,9 @@ module ActiveRecord
         end
 
         def configuration_host_ip(configuration)
-          return nil unless configuration["host"]
+          return nil unless configuration.host
 
-          Socket::getaddrinfo(configuration["host"], "echo", Socket::AF_INET)[0][3]
+          Socket::getaddrinfo(configuration.host, "echo", Socket::AF_INET)[0][3]
         end
 
         def local_ipaddr?(host_ip)

data/lib/arel/visitors/sqlserver.rb

@@ -11,13 +11,14 @@ module Arel
 
       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 bind_block; BIND_BLOCK; end
 
-      def visit_Arel_Nodes_Bin o, collector
+      def visit_Arel_Nodes_Bin(o, collector)
         visit o.expr, collector
         collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
       end
@@ -28,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
+      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
@@ -63,7 +64,38 @@ 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
@@ -80,7 +112,17 @@ 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
@@ -102,7 +144,7 @@ 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
@@ -114,39 +156,53 @@ module Arel
         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,13 +223,25 @@ 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)
@@ -190,7 +258,7 @@ 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
@@ -203,7 +271,7 @@ module Arel
         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 }
@@ -214,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
@@ -225,15 +293,28 @@ 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)
+        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
@@ -247,6 +328,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