activerecord-sqlserver-adapter 7.0.4.0 → 7.1.0.beta1

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

@@ -23,10 +23,10 @@ module ActiveRecord
               pktable = fkdata["PKTABLE_NAME"]
               pkcolmn = fkdata["PKCOLUMN_NAME"]
               remove_foreign_key fktable, name: fkdata["FK_NAME"]
-              do_execute "DELETE FROM #{quote_table_name(fktable)} WHERE #{quote_column_name(fkcolmn)} IN ( SELECT #{quote_column_name(pkcolmn)} FROM #{quote_table_name(pktable)} )"
+              execute "DELETE FROM #{quote_table_name(fktable)} WHERE #{quote_column_name(fkcolmn)} IN ( SELECT #{quote_column_name(pkcolmn)} FROM #{quote_table_name(pktable)} )"
             end
           end
-          if options[:if_exists] && @version_year < 2016
+          if options[:if_exists] && version_year < 2016
             execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}", "SCHEMA"
           else
             super
@@ -39,12 +39,12 @@ module ActiveRecord
           data.reduce([]) do |indexes, index|
             index = index.with_indifferent_access
 
-            if index[:index_description] =~ /primary key/
+            if index[:index_description].match?(/primary key/)
               indexes
             else
               name    = index[:index_name]
-              unique  = index[:index_description] =~ /unique/
-              where   = select_value("SELECT [filter_definition] FROM sys.indexes WHERE name = #{quote(name)}")
+              unique  = index[:index_description].match?(/unique/)
+              where   = select_value("SELECT [filter_definition] FROM sys.indexes WHERE name = #{quote(name)}", "SCHEMA")
               orders  = {}
               columns = []
 
@@ -118,15 +118,20 @@ module ActiveRecord
             AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
             ORDER BY KCU.ORDINAL_POSITION ASC
           }.gsub(/[[:space:]]/, " ")
+
           binds = []
           nv128 = SQLServer::Type::UnicodeVarchar.new limit: 128
           binds << Relation::QueryAttribute.new("TABLE_NAME", identifier.object, nv128)
           binds << Relation::QueryAttribute.new("TABLE_SCHEMA", identifier.schema, nv128) unless identifier.schema.blank?
-          sp_executesql(sql, "SCHEMA", binds).map { |r| r["name"] }
+
+          internal_exec_query(sql, "SCHEMA", binds).map { |row| row["name"] }
         end
 
-        def rename_table(table_name, new_name)
-          do_execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
+        def rename_table(table_name, new_name, **options)
+          validate_table_length!(new_name) unless options[:_uses_legacy_table_name]
+          schema_cache.clear_data_source_cache!(table_name.to_s)
+          schema_cache.clear_data_source_cache!(new_name.to_s)
+          execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
           rename_table_indexes(table_name, new_name)
         end
 
@@ -137,7 +142,7 @@ module ActiveRecord
           remove_check_constraints(table_name, column_name)
           remove_default_constraint(table_name, column_name)
           remove_indexes(table_name, column_name)
-          do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
         end
 
         def change_column(table_name, column_name, type, options = {})
@@ -182,7 +187,7 @@ module ActiveRecord
             sql_commands << "CREATE INDEX #{quote_table_name(index.name)} ON #{quote_table_name(table_name)} (#{index.columns.map { |c| quote_column_name(c) }.join(', ')})"
           end
 
-          sql_commands.each { |c| do_execute(c) }
+          sql_commands.each { |c| execute(c) }
           clear_cache!
         end
 
@@ -193,7 +198,7 @@ module ActiveRecord
 
           remove_default_constraint(table_name, column_name)
           default = extract_new_default_value(default_or_changes)
-          do_execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_expression(default, column)} FOR #{quote_column_name(column_name)}"
+          execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_expression(default, column)} FOR #{quote_column_name(column_name)}"
           clear_cache!
         end
 
@@ -213,23 +218,45 @@ module ActiveRecord
         end
 
         def remove_index!(table_name, index_name)
-          do_execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
+          execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
+        end
+
+        def build_change_column_definition(table_name, column_name, type, **options) # :nodoc:
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column_name, type, **options)
+          ChangeColumnDefinition.new(cd, column_name)
+        end
+
+        def build_change_column_default_definition(table_name, column_name, default_or_changes) # :nodoc:
+          column = column_for(table_name, column_name)
+          return unless column
+
+          default = extract_new_default_value(default_or_changes)
+          ChangeColumnDefaultDefinition.new(column, default)
         end
 
         def foreign_keys(table_name)
           identifier = SQLServer::Utils.extract_identifiers(table_name)
           fk_info = execute_procedure :sp_fkeys, nil, identifier.schema, nil, identifier.object, identifier.schema
-          fk_info.map do |row|
-            from_table = identifier.object
-            to_table = row["PKTABLE_NAME"]
+
+          grouped_fk = fk_info.group_by { |row| row["FK_NAME"] }.values.each { |group| group.sort_by! { |row| row["KEY_SEQ"] } }
+          grouped_fk.map do |group|
+            row = group.first
             options = {
               name: row["FK_NAME"],
-              column: row["FKCOLUMN_NAME"],
-              primary_key: row["PKCOLUMN_NAME"],
               on_update: extract_foreign_key_action("update", row["FK_NAME"]),
               on_delete: extract_foreign_key_action("delete", row["FK_NAME"])
             }
-            ForeignKeyDefinition.new from_table, to_table, options
+
+            if group.one?
+              options[:column] = row["FKCOLUMN_NAME"]
+              options[:primary_key] = row["PKCOLUMN_NAME"]
+            else
+              options[:column] = group.map { |row| row["FKCOLUMN_NAME"] }
+              options[:primary_key] = group.map { |row| row["PKCOLUMN_NAME"] }
+            end
+
+            ForeignKeyDefinition.new(identifier.object, row["PKTABLE_NAME"], options)
           end
         end
 
@@ -268,6 +295,13 @@ module ActiveRecord
           end
         end
 
+        # In SQL Server only the first column added should have the `ADD` keyword.
+        def add_timestamps(table_name, **options)
+          fragments = add_timestamps_for_alter(table_name, **options)
+          fragments[1..].each { |fragment| fragment.sub!('ADD ', '') }
+          execute "ALTER TABLE #{quote_table_name(table_name)} #{fragments.join(', ')}"
+        end
+
         def columns_for_distinct(columns, orders)
           order_columns = orders.reject(&:blank?).map { |s|
                             s = s.to_sql unless s.is_a?(String)
@@ -282,16 +316,19 @@ module ActiveRecord
           SQLServer::Table.new(table_name, base)
         end
 
-        def change_column_null(table_name, column_name, allow_null, default = nil)
+        def change_column_null(table_name, column_name, null, default = nil)
+          validate_change_column_null_argument!(null)
+
           table_id = SQLServer::Utils.extract_identifiers(table_name)
           column_id = SQLServer::Utils.extract_identifiers(column_name)
           column = column_for(table_name, column_name)
-          if !allow_null.nil? && allow_null == false && !default.nil?
-            do_execute("UPDATE #{table_id} SET #{column_id}=#{quote(default)} WHERE #{column_id} IS NULL")
+          if !null.nil? && null == false && !default.nil?
+            execute("UPDATE #{table_id} SET #{column_id}=#{quote(default)} WHERE #{column_id} IS NULL")
           end
           sql = "ALTER TABLE #{table_id} ALTER COLUMN #{column_id} #{type_to_sql column.type, limit: column.limit, precision: column.precision, scale: column.scale}"
-          sql += " NOT NULL" if !allow_null.nil? && allow_null == false
-          do_execute sql
+          sql += " NOT NULL" if !null.nil? && null == false
+
+          execute sql
         end
 
         def create_schema_dumper(options)
@@ -387,12 +424,13 @@ module ActiveRecord
           view_tblnm  = view_table_name(table_name) if view_exists
 
           if view_exists
-            results = sp_executesql %{
-              SELECT c.COLUMN_NAME AS [name], c.COLUMN_DEFAULT AS [default]
+            sql = <<~SQL
+              SELECT LOWER(c.COLUMN_NAME) AS [name], c.COLUMN_DEFAULT AS [default]
               FROM #{database}.INFORMATION_SCHEMA.COLUMNS c
               WHERE c.TABLE_NAME = #{quote(view_tblnm)}
-            }.squish, "SCHEMA", []
-            default_functions = results.each.with_object({}) {|row, out| out[row["name"]] = row["default"] }.compact
+            SQL
+            results = internal_exec_query(sql, "SCHEMA")
+            default_functions = results.each.with_object({}) { |row, out| out[row["name"]] = row["default"] }.compact
           end
 
           sql = column_definitions_sql(database, identifier)
@@ -401,7 +439,8 @@ module ActiveRecord
           nv128 = SQLServer::Type::UnicodeVarchar.new limit: 128
           binds << Relation::QueryAttribute.new("TABLE_NAME", identifier.object, nv128)
           binds << Relation::QueryAttribute.new("TABLE_SCHEMA", identifier.schema, nv128) unless identifier.schema.blank?
-          results = sp_executesql(sql, "SCHEMA", binds)
+          results = internal_exec_query(sql, "SCHEMA", binds)
+
           columns = results.map do |ci|
             ci = ci.symbolize_keys
             ci[:_type] = ci[:type]
@@ -426,7 +465,7 @@ module ActiveRecord
             ci[:default_function] = begin
               default = ci[:default_value]
               if default.nil? && view_exists
-                view_column = views_real_column_name(table_name, ci[:name])
+                view_column = views_real_column_name(table_name, ci[:name]).downcase
                 default = default_functions[view_column] if view_column.present?
               end
               case default
@@ -543,7 +582,7 @@ module ActiveRecord
         def remove_check_constraints(table_name, column_name)
           constraints = select_values "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{quote_string(table_name)}' and COLUMN_NAME = '#{quote_string(column_name)}'", "SCHEMA"
           constraints.each do |constraint|
-            do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(constraint)}"
+            execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(constraint)}"
           end
         end
 
@@ -552,7 +591,7 @@ module ActiveRecord
           execute_procedure(:sp_helpconstraint, table_name, "nomsg").flatten.select do |row|
             row["constraint_type"] == "DEFAULT on column #{column_name}"
           end.each do |row|
-            do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{row['constraint_name']}"
+            execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{row['constraint_name']}"
           end
         end
 
@@ -620,7 +659,7 @@ module ActiveRecord
           view_definition = view_information(table_name)[:VIEW_DEFINITION]
           return column_name unless view_definition
 
-          match_data = view_definition.match(/([\w-]*)\s+as\s+#{column_name}/im)
+          match_data = view_definition.match(/CREATE\s+VIEW.*AS\s+SELECT.*\W([\w-]*)\s+AS\s+#{column_name}/im)
           match_data ? match_data[1] : column_name
         end
 

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

@@ -12,9 +12,9 @@ module ActiveRecord
         OPTION_XML  = "SHOWPLAN_XML"
         OPTIONS = [OPTION_ALL, OPTION_TEXT, OPTION_XML]
 
-        def explain(arel, binds = [])
+        def explain(arel, binds = [], options = [])
           sql = to_sql(arel)
-          result = with_showplan_on { sp_executesql(sql, "EXPLAIN", binds) }
+          result = with_showplan_on { internal_exec_query(sql, "EXPLAIN", binds) }
           printer = showplan_printer.new(result)
           printer.pp
         end
@@ -30,7 +30,7 @@ module ActiveRecord
 
         def set_showplan_option(enable = true)
           sql = "SET #{showplan_option} #{enable ? 'ON' : 'OFF'}"
-          raw_connection_do(sql)
+          raw_execute(sql, "SCHEMA")
         rescue Exception
           raise ActiveRecordError, "#{showplan_option} could not be turned #{enable ? 'ON' : 'OFF'}, perhaps you do not have SHOWPLAN permissions?"
         end

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

@@ -113,6 +113,12 @@ module ActiveRecord
 
           super
         end
+
+        private
+
+        def valid_column_definition_options
+          super + [:is_identity]
+        end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table

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

@@ -5,14 +5,12 @@ require "active_record/connection_adapters/abstract/transaction"
 module ActiveRecord
   module ConnectionAdapters
     module SQLServerTransaction
-      private
+      delegate :sqlserver?, to: :connection, prefix: true
 
-      def sqlserver?
-        connection.respond_to?(:sqlserver?) && connection.sqlserver?
-      end
+      private
 
       def current_isolation_level
-        return unless sqlserver?
+        return unless connection_sqlserver?
 
         level = connection.user_options_isolation_level
         # When READ_COMMITTED_SNAPSHOT is set to ON,
@@ -50,7 +48,7 @@ module ActiveRecord
       private
 
       def reset_starting_isolation_level
-        if sqlserver? && starting_isolation_level
+        if connection_sqlserver? && starting_isolation_level
           connection.set_transaction_isolation_level(starting_isolation_level)
         end
       end

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

@@ -36,6 +36,16 @@ module ActiveRecord
             self.class == other.class && value == other.value
           end
           alias :== :eql?
+
+          def self.from_msgpack_ext(string)
+            type, value = string.chomp!("msgpack_ext").split(',')
+
+            Data.new(value, type.constantize)
+          end
+
+          def to_msgpack_ext
+            [type.class.to_s, value].join(',') + "msgpack_ext"
+          end
         end
       end
     end

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"
@@ -39,7 +42,8 @@ module ActiveRecord
               SQLServer::Showplan,
               SQLServer::SchemaStatements,
               SQLServer::DatabaseLimits,
-              SQLServer::DatabaseTasks
+              SQLServer::DatabaseTasks,
+              SQLServer::Savepoints
 
       ADAPTER_NAME = "SQLServer".freeze
 
@@ -77,93 +81,38 @@ module ActiveRecord
         end
 
         def new_client(config)
-          case config[:mode]
-          when :dblib
-            require "tiny_tds"
-            dblib_connect(config)
+          TinyTds::Client.new(config)
+        rescue TinyTds::Error => error
+          if error.message.match(/database .* does not exist/i)
+            raise ActiveRecord::NoDatabaseError
           else
-            raise ArgumentError, "Unknown connection mode in #{config.inspect}."
+            raise
           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
-        end
-
-        def config_appname(config)
-          if 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
-          end
-
-          config[:appname] || rails_application_name
-        end
-
         def rails_application_name
           Rails.application.class.name.split("::").first
         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
-        perform_connection_configuration
+        @connection_parameters ||= @config
       end
 
       # === Abstract Adapter ========================================== #
 
       def arel_visitor
-        Arel::Visitors::SQLServer.new self
+        Arel::Visitors::SQLServer.new(self)
       end
 
       def valid_type?(type)
@@ -171,13 +120,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?
@@ -229,7 +172,7 @@ module ActiveRecord
       end
 
       def supports_json?
-        @version_year >= 2016
+        version_year >= 2016
       end
 
       def supports_comments?
@@ -248,12 +191,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?
@@ -272,50 +219,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"
+        execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
       end
 
       # === Abstract Adapter (Misc Support) =========================== #
@@ -356,7 +305,7 @@ module ActiveRecord
       end
 
       def database_prefix
-        @connection_options[:database_prefix]
+        @connection_parameters[:database_prefix]
       end
 
       def database_prefix_identifier(name)
@@ -372,7 +321,7 @@ module ActiveRecord
       end
 
       def inspect
-        "#<#{self.class} version: #{version}, mode: #{@connection_options[:mode]}, azure: #{sqlserver_azure?.inspect}>"
+        "#<#{self.class} version: #{version}, azure: #{sqlserver_azure?.inspect}>"
       end
 
       def combine_bind_parameters(from_clause: [], join_clause: [], where_clause: [], having_clause: [], limit: nil, offset: nil)
@@ -386,6 +335,12 @@ module ActiveRecord
         version_year
       end
 
+      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
+
       class << self
         protected
 
@@ -513,7 +468,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
@@ -534,32 +489,44 @@ 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, fetch: :rows).first.first.to_s
       end
 
       private
 
       def connect
-        @connection = self.class.new_client(@connection_options)
-        perform_connection_configuration
+        @raw_connection = self.class.new_client(@connection_parameters)
       end
 
-      def perform_connection_configuration
-        configure_connection_defaults
-        configure_connection if self.respond_to?(:configure_connection)
-      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
 
-      def configure_connection_defaults
-        @spid = _raw_select("SELECT @@SPID", fetch: :rows).first.first
-        @version_year = version_year
+        @spid = _raw_select("SELECT @@SPID", @raw_connection, fetch: :rows).first.first
 
         initialize_dateformatter
         use_database

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