activerecord-sqlserver-adapter 6.1.2.1 → 7.2.4

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "tiny_tds"
 require "base64"
 require "active_record"
 require "arel_sqlserver"
@@ -11,11 +12,13 @@ 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/preloader"
+require "active_record/connection_adapters/sqlserver/core_ext/abstract_adapter"
 require "active_record/connection_adapters/sqlserver/version"
 require "active_record/connection_adapters/sqlserver/type"
 require "active_record/connection_adapters/sqlserver/database_limits"
 require "active_record/connection_adapters/sqlserver/database_statements"
 require "active_record/connection_adapters/sqlserver/database_tasks"
+require "active_record/connection_adapters/sqlserver/savepoints"
 require "active_record/connection_adapters/sqlserver/transaction"
 require "active_record/connection_adapters/sqlserver/errors"
 require "active_record/connection_adapters/sqlserver/schema_creation"
@@ -26,12 +29,13 @@ require "active_record/connection_adapters/sqlserver/showplan"
 require "active_record/connection_adapters/sqlserver/table_definition"
 require "active_record/connection_adapters/sqlserver/quoting"
 require "active_record/connection_adapters/sqlserver/utils"
-require "active_record/sqlserver_base"
 require "active_record/connection_adapters/sqlserver_column"
 require "active_record/tasks/sqlserver_database_tasks"
 
 module ActiveRecord
   module ConnectionAdapters
+    register "sqlserver", "ActiveRecord::ConnectionAdapters::SQLServerAdapter", "active_record/connection_adapters/sqlserver_adapter"
+
     class SQLServerAdapter < AbstractAdapter
       include SQLServer::Version,
               SQLServer::Quoting,
@@ -39,7 +43,8 @@ module ActiveRecord
               SQLServer::Showplan,
               SQLServer::SchemaStatements,
               SQLServer::DatabaseLimits,
-              SQLServer::DatabaseTasks
+              SQLServer::DatabaseTasks,
+              SQLServer::Savepoints
 
       ADAPTER_NAME = "SQLServer".freeze
 
@@ -59,63 +64,31 @@ module ActiveRecord
       self.exclude_output_inserted_table_names = Concurrent::Map.new { false }
 
       class << self
-        def new_client(config)
-          case config[:mode]
-          when :dblib
-            require "tiny_tds"
-            dblib_connect(config)
-          else
-            raise ArgumentError, "Unknown connection mode in #{config.inspect}."
+        def dbconsole(config, options = {})
+          sqlserver_config = config.configuration_hash
+          args = []
+
+          args += ["-d", "#{config.database}"] if config.database
+          args += ["-U", "#{sqlserver_config[:username]}"] if sqlserver_config[:username]
+          args += ["-P", "#{sqlserver_config[:password]}"] if sqlserver_config[:password]
+
+          if sqlserver_config[:host]
+            host_arg = +"tcp:#{sqlserver_config[:host]}"
+            host_arg << ",#{sqlserver_config[:port]}" if sqlserver_config[:port]
+            args += ["-S", host_arg]
           end
-        end
 
-        def dblib_connect(config)
-          TinyTds::Client.new(
-            dataserver:    config[:dataserver],
-            host:          config[:host],
-            port:          config[:port],
-            username:      config[:username],
-            password:      config[:password],
-            database:      config[:database],
-            tds_version:   config[:tds_version] || "7.3",
-            appname:       config_appname(config),
-            login_timeout: config_login_timeout(config),
-            timeout:       config_timeout(config),
-            encoding:      config_encoding(config),
-            azure:         config[:azure],
-            contained:     config[:contained]
-          ).tap do |client|
-            if config[:azure]
-              client.execute("SET ANSI_NULLS ON").do
-              client.execute("SET ANSI_NULL_DFLT_ON ON").do
-              client.execute("SET ANSI_PADDING ON").do
-              client.execute("SET ANSI_WARNINGS ON").do
-            else
-              client.execute("SET ANSI_DEFAULTS ON").do
-            end
-            client.execute("SET QUOTED_IDENTIFIER ON").do
-            client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
-            client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
-            client.execute("SET TEXTSIZE 2147483647").do
-            client.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
-          end
-        rescue TinyTds::Error => e
-          raise ActiveRecord::NoDatabaseError if e.message.match(/database .* does not exist/i)
-          raise e
+          find_cmd_and_exec("sqlcmd", *args)
         end
 
-        def config_appname(config)
-          if self.instance_methods.include?(:configure_application_name)
-            ActiveSupport::Deprecation.warn <<~MSG.squish
-            Configuring the application name used by TinyTDS by overriding the
-            `ActiveRecord::ConnectionAdapters::SQLServerAdapter#configure_application_name`
-            instance method is no longer supported. The application name should configured
-            using the `appname` setting in the `database.yml` file instead. Consult the
-            README for further information."
-            MSG
+        def new_client(config)
+          TinyTds::Client.new(config)
+        rescue TinyTds::Error => error
+          if error.message.match(/database .* does not exist/i)
+            raise ActiveRecord::NoDatabaseError
+          else
+            raise
           end
-
-          config[:appname] || rails_application_name
         end
 
         def rails_application_name
@@ -123,30 +96,24 @@ module ActiveRecord
         rescue
           nil # Might not be in a Rails context so we fallback to `nil`.
         end
+      end
 
-        def config_login_timeout(config)
-          config[:login_timeout].present? ? config[:login_timeout].to_i : nil
-        end
-
-        def config_timeout(config)
-          config[:timeout].present? ? config[:timeout].to_i / 1000 : nil
-        end
+      def initialize(...)
+        super
 
-        def config_encoding(config)
-          config[:encoding].present? ? config[:encoding] : nil
-        end
-      end
+        @config[:tds_version] = "7.3" unless @config[:tds_version]
+        @config[:appname] = self.class.rails_application_name unless @config[:appname]
+        @config[:login_timeout] = @config[:login_timeout].present? ? @config[:login_timeout].to_i : nil
+        @config[:timeout] = @config[:timeout].present? ? @config[:timeout].to_i / 1000 : nil
+        @config[:encoding] = @config[:encoding].present? ? @config[:encoding] : nil
 
-      def initialize(connection, logger, _connection_options, config)
-        super(connection, logger, config)
-        @connection_options = config
-        configure_connection
+        @connection_parameters ||= @config
       end
 
       # === Abstract Adapter ========================================== #
 
       def arel_visitor
-        Arel::Visitors::SQLServer.new self
+        Arel::Visitors::SQLServer.new(self)
       end
 
       def valid_type?(type)
@@ -154,13 +121,7 @@ module ActiveRecord
       end
 
       def schema_creation
-        SQLServer::SchemaCreation.new self
-      end
-
-      def self.database_exists?(config)
-        !!ActiveRecord::Base.sqlserver_connection(config)
-      rescue ActiveRecord::NoDatabaseError
-        false
+        SQLServer::SchemaCreation.new(self)
       end
 
       def supports_ddl_transactions?
@@ -211,8 +172,12 @@ module ActiveRecord
         true
       end
 
+      def supports_check_constraints?
+        true
+      end
+
       def supports_json?
-        @version_year >= 2016
+        version_year >= 2016
       end
 
       def supports_comments?
@@ -231,12 +196,16 @@ module ActiveRecord
         true
       end
 
+      def supports_common_table_expressions?
+        true
+      end
+
       def supports_lazy_transactions?
         true
       end
 
       def supports_in_memory_oltp?
-        @version_year >= 2014
+        version_year >= 2014
       end
 
       def supports_insert_returning?
@@ -255,58 +224,52 @@ module ActiveRecord
         false
       end
 
+      def return_value_after_insert?(column) # :nodoc:
+        column.is_primary? || column.is_identity?
+      end
+
       def disable_referential_integrity
         tables = tables_with_referential_integrity
-        tables.each { |t| do_execute "ALTER TABLE #{quote_table_name(t)} NOCHECK CONSTRAINT ALL" }
+        tables.each { |t| execute "ALTER TABLE #{quote_table_name(t)} NOCHECK CONSTRAINT ALL" }
         yield
       ensure
-        tables.each { |t| do_execute "ALTER TABLE #{quote_table_name(t)} CHECK CONSTRAINT ALL" }
+        tables.each { |t| execute "ALTER TABLE #{quote_table_name(t)} CHECK CONSTRAINT ALL" }
       end
 
       # === Abstract Adapter (Connection Management) ================== #
 
       def active?
-        return false unless @connection
-
-        raw_connection_do "SELECT 1"
-        true
+        @raw_connection&.active?
       rescue *connection_errors
         false
       end
 
-      def reconnect!
-        super
-        disconnect!
+      def reconnect
+        @raw_connection&.close rescue nil
+        @raw_connection = nil
+        @spid = nil
+        @collation = nil
+
         connect
       end
 
       def disconnect!
         super
-        case @connection_options[:mode]
-        when :dblib
-          @connection.close rescue nil
-        end
-        @connection = nil
+
+        @raw_connection&.close rescue nil
+        @raw_connection = nil
         @spid = nil
         @collation = nil
       end
 
-      def clear_cache!
+      def clear_cache!(...)
         @view_information = nil
         super
       end
 
       def reset!
         reset_transaction
-        do_execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
-      end
-
-      def configure_connection
-        @spid = _raw_select("SELECT @@SPID", fetch: :rows).first.first
-        @version_year = version_year
-
-        initialize_dateformatter
-        use_database
+        execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
       end
 
       # === Abstract Adapter (Misc Support) =========================== #
@@ -347,7 +310,7 @@ module ActiveRecord
       end
 
       def database_prefix
-        @connection_options[:database_prefix]
+        @connection_parameters[:database_prefix]
       end
 
       def database_prefix_identifier(name)
@@ -362,10 +325,6 @@ module ActiveRecord
         self.class::VERSION
       end
 
-      def inspect
-        "#<#{self.class} version: #{version}, mode: #{@connection_options[:mode]}, azure: #{sqlserver_azure?.inspect}>"
-      end
-
       def combine_bind_parameters(from_clause: [], join_clause: [], where_clause: [], having_clause: [], limit: nil, offset: nil)
         result = from_clause + join_clause + where_clause + having_clause
         result << offset if offset
@@ -377,83 +336,99 @@ module ActiveRecord
         version_year
       end
 
-      protected
-
-      # === Abstract Adapter (Misc Support) =========================== #
+      def check_version # :nodoc:
+        if schema_cache.database_version < 2012
+          raise "Your version of SQL Server (#{database_version}) is too old. SQL Server Active Record supports 2012 or higher."
+        end
+      end
 
-      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)"
-        register_class_with_limit m, "int(4)",            SQLServer::Type::Integer
-        m.alias_type                 "integer",           "int(4)"
-        m.alias_type                 "int",               "int(4)"
-        register_class_with_limit m, "smallint(2)",       SQLServer::Type::SmallInteger
-        m.alias_type                 "smallint",          "smallint(2)"
-        register_class_with_limit m, "tinyint(1)",        SQLServer::Type::TinyInteger
-        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)
-          precision = extract_precision(sql_type)
-          if scale == 0
-            SQLServer::Type::DecimalWithoutScale.new(precision: precision)
-          else
-            SQLServer::Type::Decimal.new(precision: precision, scale: scale)
+      class << self
+        protected
+
+        def initialize_type_map(m)
+          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)"
+          register_class_with_limit m, "int(4)",            SQLServer::Type::Integer
+          m.alias_type                 "integer",           "int(4)"
+          m.alias_type                 "int",               "int(4)"
+          register_class_with_limit m, "smallint(2)",       SQLServer::Type::SmallInteger
+          m.alias_type                 "smallint",          "smallint(2)"
+          register_class_with_limit m, "tinyint(1)",        SQLServer::Type::TinyInteger
+          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)
+            precision = extract_precision(sql_type)
+            if scale == 0
+              SQLServer::Type::DecimalWithoutScale.new(precision: precision)
+            else
+              SQLServer::Type::Decimal.new(precision: precision, scale: scale)
+            end
           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|
-          precision = extract_precision(sql_type)
-          if precision
-            SQLServer::Type::DateTime2.new precision: precision
-          else
-            SQLServer::Type::DateTime.new
+          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|
+            precision = extract_precision(sql_type)
+            if precision
+              SQLServer::Type::DateTime2.new precision: precision
+            else
+              SQLServer::Type::DateTime.new
+            end
           end
+          m.register_type %r{\Adatetimeoffset}i do |sql_type|
+            precision = extract_precision(sql_type)
+            SQLServer::Type::DateTimeOffset.new precision: precision
+          end
+          m.register_type              "smalldatetime", SQLServer::Type::SmallDateTime.new
+          m.register_type              %r{\Atime}i do |sql_type|
+            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
+          m.alias_type                 "string",            "nvarchar(4000)"
+          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
         end
-        m.register_type %r{\Adatetimeoffset}i do |sql_type|
-          precision = extract_precision(sql_type)
-          SQLServer::Type::DateTimeOffset.new precision: precision
-        end
-        m.register_type              "smalldatetime", SQLServer::Type::SmallDateTime.new
-        m.register_type              %r{\Atime}i do |sql_type|
-          precision = extract_precision(sql_type) || DEFAULT_TIME_PRECISION
-          SQLServer::Type::Time.new precision: precision
-        end
+      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
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
 
-        # 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
-        m.alias_type                 "string",            "nvarchar(4000)"
-        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
+      protected
 
-        # 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
+      # === Abstract Adapter (Misc Support) =========================== #
 
-        # Other Data Types
-        m.register_type              "uniqueidentifier",  SQLServer::Type::Uuid.new
-        m.register_type              "timestamp",         SQLServer::Type::Timestamp.new
+      def type_map
+        TYPE_MAP
       end
 
       def translate_exception(e, message:, sql:, binds:)
@@ -467,7 +442,7 @@ module ActiveRecord
         when /has been chosen as the deadlock victim/i
           DeadlockVictim.new(message, sql: sql, binds: binds)
         when /database .* does not exist/i
-          NoDatabaseError.new(message, sql: sql, binds: binds)
+          NoDatabaseError.new(message)
         when /data would be truncated/
           ValueTooLong.new(message, sql: sql, binds: binds)
         when /connection timed out/
@@ -494,7 +469,7 @@ module ActiveRecord
       # === SQLServer Specific (Connection Management) ================ #
 
       def connection_errors
-        @connection_errors ||= [].tap do |errors|
+        @raw_connection_errors ||= [].tap do |errors|
           errors << TinyTds::Error if defined?(TinyTds::Error)
         end
       end
@@ -515,22 +490,47 @@ module ActiveRecord
       end
 
       def version_year
-        return 2016 if sqlserver_version =~ /vNext/
-
-        /SQL Server (\d+)/.match(sqlserver_version).to_a.last.to_s.to_i
-      rescue StandardError
-        2016
+        @version_year ||= begin
+          if sqlserver_version =~ /vNext/
+            2016
+          else
+            /SQL Server (\d+)/.match(sqlserver_version).to_a.last.to_s.to_i
+          end
+        rescue StandardError
+          2016
+        end
       end
 
       def sqlserver_version
-        @sqlserver_version ||= _raw_select("SELECT @@version", fetch: :rows).first.first.to_s
+        @sqlserver_version ||= _raw_select("SELECT @@version", @raw_connection).first.first.to_s
       end
 
       private
 
       def connect
-        @connection = self.class.new_client(@connection_options)
-        configure_connection
+        @raw_connection = self.class.new_client(@connection_parameters)
+      end
+
+      def configure_connection
+        if @config[:azure]
+          @raw_connection.execute("SET ANSI_NULLS ON").do
+          @raw_connection.execute("SET ANSI_NULL_DFLT_ON ON").do
+          @raw_connection.execute("SET ANSI_PADDING ON").do
+          @raw_connection.execute("SET ANSI_WARNINGS ON").do
+        else
+          @raw_connection.execute("SET ANSI_DEFAULTS ON").do
+        end
+
+        @raw_connection.execute("SET QUOTED_IDENTIFIER ON").do
+        @raw_connection.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
+        @raw_connection.execute("SET IMPLICIT_TRANSACTIONS OFF").do
+        @raw_connection.execute("SET TEXTSIZE 2147483647").do
+        @raw_connection.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
+
+        @spid = _raw_select("SELECT @@SPID", @raw_connection).first.first
+
+        initialize_dateformatter
+        use_database
       end
     end
   end

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -17,6 +17,7 @@ module ActiveRecord
         def is_identity?
           is_identity
         end
+        alias_method :auto_incremented_by_db?, :is_identity?
 
         def is_primary?
           is_primary