activerecord-jdbcsqlserver-adapter 50.0.0 → 52.0.0

data/lib/active_record/connection_adapters/sqlserver/core_ext/query_methods.rb

@@ -0,0 +1,26 @@
+require 'active_record/relation'
+require 'active_record/version'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module QueryMethods
+
+          private
+
+          # Copy of original from Rails master. This patch can be removed when adapter supports Rails 6.
+          def table_name_matches?(from)
+            table_name = Regexp.escape(table.name)
+            quoted_table_name = Regexp.escape(connection.quote_table_name(table.name))
+            /(?:\A|(?<!FROM)\s)(?:\b#{table_name}\b|#{quoted_table_name})(?!\.)/i.match?(from.to_s)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Relation.include(ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::QueryMethods)
+end

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

@@ -2,7 +2,6 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module DatabaseLimits
-
         def table_alias_length
           128
         end
@@ -32,7 +31,7 @@ module ActiveRecord
         end
 
         def in_clause_length
-          65_536
+          10_000
         end
 
         def sql_query_length
@@ -43,6 +42,18 @@ module ActiveRecord
           256
         end
 
+        private
+
+        # The max number of binds is 2100, but because sp_executesql takes
+        # the first 2 params as the query string and the list of types,
+        # we have only 2098 spaces left
+        def bind_params_length
+          2_098
+        end
+
+        def insert_rows_length
+          1_000
+        end
       end
     end
   end

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

@@ -3,10 +3,6 @@ module ActiveRecord
     module SQLServer
       module DatabaseStatements
 
-        def select_rows(sql, name = nil, binds = [])
-          sp_executesql sql, name, binds, fetch: :rows
-        end
-
         def execute(sql, name = nil)
           if id_insert_table_name = query_requires_identity_insert?(sql)
             with_identity_insert_enabled(id_insert_table_name) { do_execute(sql, name) }
@@ -19,26 +15,22 @@ module ActiveRecord
           sp_executesql(sql, name, binds, prepare: prepare)
         end
 
-        def exec_insert(sql, name, binds, pk = nil, _sequence_name = nil)
+        def exec_insert(sql, name = nil, binds = [], pk = nil, _sequence_name = nil)
           if id_insert_table_name = exec_insert_requires_identity?(sql, pk, binds)
-            with_identity_insert_enabled(id_insert_table_name) { exec_query(sql, name, binds) }
+            with_identity_insert_enabled(id_insert_table_name) { super(sql, name, binds, pk) }
           else
-            exec_query(sql, name, binds)
+            super(sql, name, binds, pk)
           end
         end
 
         def exec_delete(sql, name, binds)
-          sql << '; SELECT @@ROWCOUNT AS AffectedRows'
-          super.rows.first.first
+          sql = sql.dup << '; SELECT @@ROWCOUNT AS AffectedRows'
+          super(sql, name, binds).rows.first.first
         end
 
         def exec_update(sql, name, binds)
-          sql << '; SELECT @@ROWCOUNT AS AffectedRows'
-          super.rows.first.first
-        end
-
-        def supports_statement_cache?
-          true
+          sql = sql.dup << '; SELECT @@ROWCOUNT AS AffectedRows'
+          super(sql, name, binds).rows.first.first
         end
 
         def begin_db_transaction
@@ -80,18 +72,56 @@ module ActiveRecord
         end
 
         def case_sensitive_comparison(table, attribute, column, value)
-          if value && value.acts_like?(:string)
-            table[attribute].eq(Arel::Nodes::Bin.new(Arel::Nodes::BindParam.new))
+          if column.collation && !column.case_sensitive?
+            table[attribute].eq(Arel::Nodes::Bin.new(value))
           else
             super
           end
         end
 
+        # We should propose this change to Rails team
+        def insert_fixtures_set(fixture_set, tables_to_delete = [])
+          fixture_inserts = []
+
+          fixture_set.each do |table_name, fixtures|
+            fixtures.each_slice(insert_rows_length) do |batch|
+              fixture_inserts << build_fixture_sql(batch, table_name)
+            end
+          end
+
+          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}".dup }
+          total_sql = Array.wrap(combine_multi_statements(table_deletes + fixture_inserts))
+
+          disable_referential_integrity do
+            transaction(requires_new: true) do
+              total_sql.each do |sql|
+                execute sql, "Fixtures Load"
+                yield if block_given?
+              end
+            end
+          end
+        end
+
         def can_perform_case_insensitive_comparison_for?(column)
-          column.type == :string
+          column.type == :string && (!column.collation || column.case_sensitive?)
         end
         private :can_perform_case_insensitive_comparison_for?
 
+        def combine_multi_statements(total_sql)
+          total_sql
+        end
+        private :combine_multi_statements
+
+        def default_insert_value(column)
+          if column.is_identity?
+            table_name = quote(quote_table_name(column.table_name))
+            Arel.sql("IDENT_CURRENT(#{table_name}) + IDENT_INCR(#{table_name})")
+          else
+            super
+          end
+        end
+        private :default_insert_value
+
         # === SQLServer Specific ======================================== #
 
         def execute_procedure(proc_name, *variables)
@@ -196,9 +226,20 @@ module ActiveRecord
             table_name = query_requires_identity_insert?(sql)
             pk = primary_key(table_name)
           end
-          sql = if pk && self.class.use_output_inserted && !database_prefix_remote_server?
+          sql = if pk && use_output_inserted? && !database_prefix_remote_server?
                   quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
-                  sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                  table_name ||= get_table_name(sql)
+                  exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
+                  if exclude_output_inserted
+                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? 'bigint' : exclude_output_inserted
+                    <<-SQL.strip_heredoc
+                      DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
+                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
+                      SELECT CAST(#{quoted_pk} AS #{id_sql_type}) FROM @ssaIdInsertTable
+                    SQL
+                  else
+                    sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                  end
                 else
                   "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
                 end
@@ -231,6 +272,8 @@ module ActiveRecord
         def sp_executesql_types_and_parameters(binds)
           types, params = [], []
           binds.each_with_index do |attr, index|
+            attr = attr.value if attr.is_a?(Arel::Nodes::BindParam)
+
             types << "@#{index} #{sp_executesql_sql_type(attr)}"
             params << sp_executesql_sql_param(attr)
           end
@@ -241,19 +284,19 @@ module ActiveRecord
           return attr.type.sqlserver_type if attr.type.respond_to?(:sqlserver_type)
           case value = attr.value_for_database
           when Numeric
-            'int'.freeze
+            value > 2_147_483_647 ? 'bigint'.freeze : 'int'.freeze
           else
             'nvarchar(max)'.freeze
           end
         end
 
         def sp_executesql_sql_param(attr)
-          case attr.value_for_database
+          case value = attr.value_for_database
           when Type::Binary::Data,
                ActiveRecord::Type::SQLServer::Data
-            quote(attr.value_for_database)
+            quote(value)
           else
-            quote(type_cast(attr.value_for_database))
+            quote(type_cast(value))
           end
         end
 
@@ -261,7 +304,7 @@ module ActiveRecord
           if name == 'EXPLAIN'
             params.each.with_index do |param, index|
               substitute_at_finder = /(@#{index})(?=(?:[^']|'[^']*')*$)/ # Finds unquoted @n values.
-              sql.sub! substitute_at_finder, param.to_s
+              sql = sql.sub substitute_at_finder, param.to_s
             end
           else
             types = quote(types.join(', '))
@@ -275,7 +318,14 @@ module ActiveRecord
         def raw_connection_do(sql)
           case @connection_options[:mode]
           when :dblib
-            @connection.execute(sql).do
+            result = @connection.execute(sql)
+
+            # TinyTDS returns false instead of raising an exception if connection fails.
+            # Getting around this by raising an exception ourselves while this PR
+            # https://github.com/rails-sqlserver/tiny_tds/pull/469 is not released.
+            raise TinyTds::Error, "failed to execute statement" if result.is_a?(FalseClass)
+
+            result.do
           end
         ensure
           @update_sql = false
@@ -283,15 +333,31 @@ module ActiveRecord
 
         # === SQLServer Specific (Identity Inserts) ===================== #
 
+        def use_output_inserted?
+          self.class.use_output_inserted
+        end
+
+        def exclude_output_inserted_table_names?
+          !self.class.exclude_output_inserted_table_names.empty?
+        end
+
+        def exclude_output_inserted_table_name?(table_name, sql)
+          return false unless exclude_output_inserted_table_names?
+          table_name ||= get_table_name(sql)
+          return false unless table_name
+          self.class.exclude_output_inserted_table_names[table_name]
+        end
+
         def exec_insert_requires_identity?(sql, pk, binds)
-          query_requires_identity_insert?(sql) if pk && binds.map(&:name).include?(pk)
+          query_requires_identity_insert?(sql)
         end
 
         def query_requires_identity_insert?(sql)
           if insert_sql?(sql)
             table_name = get_table_name(sql)
             id_column = identity_columns(table_name).first
-            id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
+            # id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
+            id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? table_name : false
           else
             false
           end

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

@@ -12,6 +12,7 @@ module ActiveRecord
 
         def drop_database(database)
           name = SQLServer::Utils.extract_identifiers(database)
+          do_execute "ALTER DATABASE #{name} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
           do_execute "DROP DATABASE #{name}"
         end
 

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

@@ -90,18 +90,6 @@ module ActiveRecord
           @connection.configure_connection
         end
 
-        # @Overwrite
-        # Had some special logic and skipped using gem's internal query methods
-        def select_rows(sql, name = nil, binds = [])
-
-          # In some cases the limit is converted to a `TOP(1)` but the bind parameter is still in the array
-          if !binds.empty? && sql.include?('TOP(1)')
-            binds = binds.delete_if {|b| b.name == 'LIMIT' }
-          end
-
-          exec_query(sql, name, binds).rows
-        end
-
         # Have to reset this because the default arjdbc functionality is to return false unless a level is passed in
         def supports_transaction_isolation?
           true
@@ -152,25 +140,17 @@ module ActiveRecord
           [sql, binds, pk, sequence_name]
         end
 
+        # @Override original version uses driver specific query command
+        def sqlserver_version
+          @sqlserver_version ||= select_value('SELECT @@version').to_s
+        end
+
         # @Override
         def translate_exception(exception, message)
           return ActiveRecord::ValueTooLong.new(message) if exception.message.include?('java.sql.DataTruncation')
           super
         end
 
-        # @Overwrite
-        # Made it so we don't use the internal calls from the gem
-        def version_year
-          return @version_year if defined?(@version_year)
-          @version_year = begin
-            vstring = select_value('SELECT @@version').to_s
-            return 2016 if vstring =~ /vNext/
-            /SQL Server (\d+)/.match(vstring).to_a.last.to_s.to_i
-          rescue Exception => e
-            2016
-          end
-        end
-
         private
 
         def _quote(value)

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

@@ -8,7 +8,8 @@ module ActiveRecord
         def visit_TableDefinition(o)
           if o.as
             table_name = quote_table_name(o.temporary ? "##{o.name}" : o.name)
-            projections, source = @conn.to_sql(o.as).match(%r{SELECT\s+(.*)?\s+FROM\s+(.*)?}).captures
+            query = o.as.respond_to?(:to_sql) ? o.as.to_sql : o.as
+            projections, source = query.match(%r{SELECT\s+(.*)?\s+FROM\s+(.*)?}).captures
             select_into = "SELECT #{projections} INTO #{table_name} FROM #{source}"
           else
             o.instance_variable_set :@as, nil
@@ -16,6 +17,20 @@ module ActiveRecord
           end
         end
 
+        def add_column_options!(sql, options)
+          sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
+          if options[:null] == false
+            sql << " NOT NULL"
+          end
+          if options[:is_identity] == true
+            sql << " IDENTITY(1,1)"
+          end
+          if options[:primary_key] == true
+            sql << " PRIMARY KEY"
+          end
+          sql
+        end
+
         def action_sql(action, dependency)
           case dependency
           when :restrict
@@ -28,6 +43,14 @@ module ActiveRecord
           end
         end
 
+        def options_include_default?(options)
+          super || options_primary_key_with_nil_default?(options)
+        end
+
+        def options_primary_key_with_nil_default?(options)
+          options[:primary_key] && options.include?(:default) && options[:default].nil?
+        end
+
       end
     end
   end

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

@@ -1,13 +1,34 @@
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
-      module SchemaDumper
+      class SchemaDumper < ConnectionAdapters::SchemaDumper
+
+        SQLSEVER_NO_LIMIT_TYPES = [
+          'text',
+          'ntext',
+          'varchar(max)',
+          'nvarchar(max)',
+          'varbinary(max)'
+        ].freeze
 
         private
 
+        def explicit_primary_key_default?(column)
+          column.is_primary? && !column.is_identity?
+        end
+
+        def schema_limit(column)
+          return if SQLSEVER_NO_LIMIT_TYPES.include?(column.sql_type)
+          super
+        end
+
         def schema_collation(column)
           return unless column.collation
-          column.collation if column.collation != collation
+          column.collation if column.collation != @connection.collation
+        end
+
+        def default_primary_key?(column)
+          super && column.is_primary? && column.is_identity?
         end
 
       end

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

@@ -7,35 +7,6 @@ module ActiveRecord
           @native_database_types ||= initialize_native_database_types.freeze
         end
 
-        def tables(name = nil)
-          ActiveSupport::Deprecation.warn 'Passing arguments to #tables is deprecated without replacement.' if name
-          tables_sql('BASE TABLE')
-        end
-
-        def table_exists?(table_name)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            #table_exists? currently checks both tables and views.
-            This behavior is deprecated and will be changed with Rails 5.1 to only check tables.
-            Use #data_source_exists? instead.
-          MSG
-          data_source_exists?(table_name)
-        end
-
-        def data_source_exists?(table_name)
-          return false if table_name.blank?
-          unquoted_table_name = SQLServer::Utils.extract_identifiers(table_name).object
-          super(unquoted_table_name)
-        end
-
-        def views
-          tables_sql('VIEW')
-        end
-
-        def view_exists?(table_name)
-          identifier = SQLServer::Utils.extract_identifiers(table_name)
-          super(identifier.object)
-        end
-
         def create_table(table_name, comment: nil, **options)
           res = super
           clear_cache!
@@ -43,29 +14,50 @@ module ActiveRecord
         end
 
         def drop_table(table_name, options = {})
-          if options[:if_exists] && @version_year != 2016
+          # Mimic CASCADE option as best we can.
+          if options[:force] == :cascade
+            execute_procedure(:sp_fkeys, pktable_name: table_name).each do |fkdata|
+              fktable = fkdata['FKTABLE_NAME']
+              fkcolmn = fkdata['FKCOLUMN_NAME']
+              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)} )"
+            end
+          end
+          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)}"
           else
             super
           end
         end
 
-        def indexes(table_name, name = nil)
-          data = (select("EXEC sp_helpindex #{quote(table_name)}", name) || []) rescue [] # JDBC returns nil instead of an array or erring out for no results
+        def indexes(table_name)
+          data = (select("EXEC sp_helpindex #{quote(table_name)}", "SCHEMA") || []) rescue [] # JDBC returns nil instead of an array or erring out for no results
           data.reduce([]) do |indexes, index|
             index = index.with_indifferent_access
+
             if index[:index_description] =~ /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)}")
-              columns = index[:index_keys].split(',').map do |column|
+              orders  = {}
+              columns = []
+
+              index[:index_keys].split(',').each do |column|
                 column.strip!
-                column.gsub! '(-)', '' if column.ends_with?('(-)')
-                column
+
+                if column.ends_with?('(-)')
+                  column.gsub! '(-)', ''
+                  orders[column] = :desc
+                end
+
+                columns << column
               end
-              indexes << IndexDefinition.new(table_name, name, unique, columns, nil, nil, where)
+
+              indexes << IndexDefinition.new(table_name, name, unique, columns, where: where, orders: orders)
             end
           end
         end
@@ -103,10 +95,36 @@ module ActiveRecord
         end
 
         def primary_keys(table_name)
-          primaries = schema_cache.columns(table_name).select(&:is_primary?).map(&:name)
+          primaries = primary_keys_select(table_name)
           primaries.present? ? primaries : identity_columns(table_name).map(&:name)
         end
 
+        def primary_keys_select(table_name)
+          identifier = database_prefix_identifier(table_name)
+          database = identifier.fully_qualified_database_quoted
+          sql = %{
+            SELECT KCU.COLUMN_NAME AS [name]
+            FROM #{database}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
+            LEFT OUTER JOIN #{database}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
+              ON KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
+              AND KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
+              AND KCU.CONSTRAINT_CATALOG = TC.CONSTRAINT_CATALOG
+              AND KCU.CONSTRAINT_SCHEMA = TC.CONSTRAINT_SCHEMA
+              AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
+            WHERE KCU.TABLE_NAME = #{prepared_statements ? COLUMN_DEFINITION_BIND_STRING_0 : quote(identifier.object)}
+            AND KCU.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : (prepared_statements ? COLUMN_DEFINITION_BIND_STRING_1 : quote(identifier.schema))}
+            AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
+            ORDER BY KCU.ORDINAL_POSITION ASC
+          }.gsub(/[[:space:]]/, ' ')
+          binds = []
+          if prepared_statements
+            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?
+          end
+          sp_executesql(sql, 'SCHEMA', binds).map { |r| r['name'] }
+        end
+
         def rename_table(table_name, new_name)
           do_execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
           rename_table_indexes(table_name, new_name)
@@ -124,22 +142,30 @@ module ActiveRecord
           sql_commands = []
           indexes = []
           column_object = schema_cache.columns(table_name).find { |c| c.name.to_s == column_name.to_s }
-          if options_include_default?(options) || (column_object && column_object.type != type.to_sym)
+          without_constraints = options.key?(:default) || options.key?(:limit)
+          default = if !options.key?(:default) && column_object
+            column_object.default
+          else
+            options[:default]
+          end
+          if without_constraints || (column_object && column_object.type != type.to_sym)
             remove_default_constraint(table_name, column_name)
             indexes = indexes(table_name).select { |index| index.columns.include?(column_name.to_s) }
             remove_indexes(table_name, column_name)
           end
           sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(options[:default], column_object)} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
-          sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-          sql_commands[-1] << ' NOT NULL' if !options[:null].nil? && options[:null] == false
-          if options_include_default?(options)
-            sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_expression(options[:default], column_object)} FOR #{quote_column_name(column_name)}"
+          sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, limit: options[:limit], precision: options[:precision], scale: options[:scale])}"
+          sql_commands.last << ' NOT NULL' if !options[:null].nil? && options[:null] == false
+          if without_constraints
+            default = quote_default_expression(default, column_object || column_for(table_name, column_name))
+            sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{default} FOR #{quote_column_name(column_name)}"
           end
           # Add any removed indexes back
           indexes.each do |index|
             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) }
+          clear_cache!
         end
 
         def change_column_default(table_name, column_name, default_or_changes)
@@ -194,13 +220,14 @@ module ActiveRecord
           end
         end
 
-        def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **)
           type_limitable = %w(string integer float char nchar varchar nvarchar).include?(type.to_s)
           limit = nil unless type_limitable
           case type.to_s
           when 'integer'
             case limit
-            when 1..2       then  'smallint'
+            when 1          then  'tinyint'
+            when 2          then  'smallint'
             when 3..4, nil  then  'integer'
             when 5..8       then  'bigint'
             else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
@@ -226,7 +253,8 @@ module ActiveRecord
               s.gsub(/\s+(?:ASC|DESC)\b/i, '')
                .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, '')
             }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
-          [super, *order_columns].join(', ')
+
+          (order_columns << super).join(", ")
         end
 
         def update_table_definition(table_name, base)
@@ -236,23 +264,48 @@ module ActiveRecord
         def change_column_null(table_name, column_name, allow_null, default = nil)
           table_id = SQLServer::Utils.extract_identifiers(table_name)
           column_id = SQLServer::Utils.extract_identifiers(column_name)
-          column = detect_column_for! table_name, 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")
           end
-          sql = "ALTER TABLE #{table_id} ALTER COLUMN #{column_id} #{type_to_sql column.type, column.limit, column.precision, column.scale}"
+          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
         end
 
+        def create_schema_dumper(options)
+          SQLServer::SchemaDumper.create(self, options)
+        end
+
+        private
 
-        protected
+        def data_source_sql(name = nil, type: nil)
+          scope = quoted_scope name, type: type
+          table_name = lowercase_schema_reflection_sql 'TABLE_NAME'
+          sql = "SELECT #{table_name}"
+          sql << ' FROM INFORMATION_SCHEMA.TABLES WITH (NOLOCK)'
+          sql << ' WHERE TABLE_CATALOG = DB_NAME()'
+          sql << " AND TABLE_SCHEMA = #{quote(scope[:schema])}"
+          sql << " AND TABLE_NAME = #{quote(scope[:name])}" if scope[:name]
+          sql << " AND TABLE_TYPE = #{quote(scope[:type])}" if scope[:type]
+          sql << " ORDER BY #{table_name}"
+          sql
+        end
+
+        def quoted_scope(name = nil, type: nil)
+          identifier = SQLServer::Utils.extract_identifiers(name)
+          {}.tap do |scope|
+            scope[:schema] = identifier.schema || 'dbo'
+            scope[:name] = identifier.object if identifier.object
+            scope[:type] = type if type
+          end
+        end
 
         # === SQLServer Specific ======================================== #
 
         def initialize_native_database_types
           {
-            primary_key: 'int NOT NULL IDENTITY(1,1) PRIMARY KEY',
+            primary_key: 'bigint NOT NULL IDENTITY(1,1) PRIMARY KEY',
             primary_key_nonclustered: 'int NOT NULL IDENTITY(1,1) PRIMARY KEY NONCLUSTERED',
             integer: { name: 'int', limit: 4 },
             bigint: { name: 'bigint' },
@@ -286,21 +339,11 @@ module ActiveRecord
           }
         end
 
-        def tables_sql(type)
-          tn  = lowercase_schema_reflection_sql 'TABLE_NAME'
-          sql = "SELECT #{tn} FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = '#{type}' ORDER BY TABLE_NAME"
-          select_values sql, 'SCHEMA'
-        end
-
         COLUMN_DEFINITION_BIND_STRING_0 = defined?(JRUBY_VERSION) ? '?' : '@0'
         COLUMN_DEFINITION_BIND_STRING_1 = defined?(JRUBY_VERSION) ? '?' : '@1'
 
         def column_definitions(table_name)
-          identifier = if database_prefix_remote_server?
-            SQLServer::Utils.extract_identifiers("#{database_prefix}#{table_name}")
-          else
-            SQLServer::Utils.extract_identifiers(table_name)
-          end
+          identifier  = database_prefix_identifier(table_name)
           database    = identifier.fully_qualified_database_quoted
           view_exists = view_exists?(table_name)
           view_tblnm  = view_table_name(table_name) if view_exists
@@ -386,11 +429,13 @@ module ActiveRecord
             ci[:default_function] = begin
               default = ci[:default_value]
               if default.nil? && view_exists
-                default = select_value "
+                default = select_value %{
                   SELECT c.COLUMN_DEFAULT
                   FROM #{database}.INFORMATION_SCHEMA.COLUMNS c
-                  WHERE c.TABLE_NAME = '#{view_tblnm}'
-                  AND c.COLUMN_NAME = '#{views_real_column_name(table_name, ci[:name])}'".squish, 'SCHEMA'
+                  WHERE
+                    c.TABLE_NAME = '#{view_tblnm}'
+                    AND c.COLUMN_NAME = '#{views_real_column_name(table_name, ci[:name])}'
+                }.squish, 'SCHEMA'
               end
               case default
               when nil
@@ -409,7 +454,7 @@ module ActiveRecord
                        else ci[:type]
                        end
                 value = default.match(/\A\((.*)\)\Z/m)[1]
-                value = select_value "SELECT CAST(#{value} AS #{type}) AS value", 'SCHEMA'
+                value = select_value("SELECT CAST(#{value} AS #{type}) AS value", 'SCHEMA')
                 [value, nil]
               end
             end
@@ -460,13 +505,6 @@ module ActiveRecord
           "DF_#{table_name}_#{column_name}"
         end
 
-        def detect_column_for!(table_name, column_name)
-          unless column = schema_cache.columns(table_name).find { |c| c.name == column_name.to_s }
-            raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
-          end
-          column
-        end
-
         def lowercase_schema_reflection_sql(node)
           lowercase_schema_reflection ? "LOWER(#{node})" : node
         end
@@ -482,7 +520,7 @@ module ActiveRecord
           @view_information ||= {}
           @view_information[table_name] ||= begin
             identifier = SQLServer::Utils.extract_identifiers(table_name)
-            view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{identifier.object}'", 'SCHEMA'
+            view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WITH (NOLOCK) WHERE TABLE_NAME = #{quote(identifier.object)}", 'SCHEMA'
             if view_info
               view_info = view_info.with_indifferent_access
               if view_info[:VIEW_DEFINITION].blank? || view_info[:VIEW_DEFINITION].length == 4000
@@ -505,8 +543,6 @@ module ActiveRecord
           match_data ? match_data[1] : column_name
         end
 
-        private
-
         def create_table_definition(*args)
           SQLServer::TableDefinition.new(*args)
         end