activerecord-jdbcsqlserver-adapter 50.0.0

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

@@ -0,0 +1,67 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module DatabaseTasks
+
+        def create_database(database, options = {})
+          name = SQLServer::Utils.extract_identifiers(database)
+          db_options = create_database_options(options)
+          edition_options = create_database_edition_options(options)
+          do_execute "CREATE DATABASE #{name} #{db_options} #{edition_options}"
+        end
+
+        def drop_database(database)
+          name = SQLServer::Utils.extract_identifiers(database)
+          do_execute "DROP DATABASE #{name}"
+        end
+
+        def current_database
+          select_value 'SELECT DB_NAME()'
+        end
+
+        def charset
+          select_value "SELECT DATABASEPROPERTYEX(DB_NAME(), 'SqlCharSetName')"
+        end
+
+        def collation
+          @collation ||= select_value "SELECT DATABASEPROPERTYEX(DB_NAME(), 'Collation')"
+        end
+
+        private
+
+        def create_database_options(options={})
+          keys  = [:collate]
+          copts = @connection_options
+          options = {
+            collate: copts[:collation]
+          }.merge(options.symbolize_keys).select { |_, v|
+            v.present?
+          }.slice(*keys).map { |k,v|
+            "#{k.to_s.upcase} #{v}"
+          }.join(' ')
+          options
+        end
+
+        def create_database_edition_options(options={})
+          keys  = [:maxsize, :edition, :service_objective]
+          copts = @connection_options
+          edition_options = {
+            maxsize: copts[:azure_maxsize],
+            edition: copts[:azure_edition],
+            service_objective: copts[:azure_service_objective]
+          }.merge(options.symbolize_keys).select { |_, v|
+            v.present?
+          }.slice(*keys).map { |k,v|
+            "#{k.to_s.upcase} = #{v}"
+          }.join(', ')
+          edition_options = "( #{edition_options} )" if edition_options.present?
+          edition_options
+        end
+
+      end
+    end
+  end
+end
+
+
+

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

@@ -0,0 +1,7 @@
+module ActiveRecord
+
+  class DeadlockVictim < WrappedDatabaseException
+  end
+
+
+end

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

@@ -0,0 +1,192 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module JDBCOverrides
+
+        # @Override
+        # Needed to reapply this since the jdbc abstract versions don't do the check and
+        # end up overriding the sqlserver gem's version
+        def exec_insert(sql, name, 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) { super }
+          else
+            super
+          end
+        end
+
+        # @Override
+        # Needed to reapply this since the jdbc abstract versions don't do the check and
+        # end up overriding the sqlserver gem's version
+        def execute(sql, name = nil)
+          if id_insert_table_name = query_requires_identity_insert?(sql)
+            with_identity_insert_enabled(id_insert_table_name) { super }
+          else
+            super
+          end
+        end
+
+        # TODO Move to java for potential perf boost
+        def execute_procedure(proc_name, *variables, &block)
+          vars = if variables.any? && variables.first.is_a?(Hash)
+                   variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
+                 else
+                   variables.map { |v| quote(v) }
+                 end.join(', ')
+          sql = "EXEC #{proc_name} #{vars}".strip
+          log(sql, 'Execute Procedure') do
+            result = @connection.execute(sql)
+
+            return [] unless result
+
+            if result.is_a?(Array)
+              result.map! do |res|
+                process_execute_procedure_result(res, &block)
+              end
+            else
+              result = process_execute_procedure_result(result, &block)
+            end
+
+            result
+          end
+        end
+
+        # @Override
+        # MSSQL does not return query plans for prepared statements, so we have to unprepare them
+        # SQLServer gem handles this by overridding exec_explain but that doesn't correctly unprepare them for our needs
+        def explain(arel, binds = [])
+          arel = ActiveRecord::Base.send(:replace_bind_variables, arel, binds.map(&:value_for_database))
+          sql = to_sql(arel)
+          result = with_showplan_on { execute(sql, 'EXPLAIN') }
+          if result.is_a?(Array)
+            # We got back multiple result sets but the printer expects them to all be in one
+            main_result = result[0]
+            result.each_with_index do |result_obj, i|
+              next if i == 0
+              main_result.rows.concat(result_obj.rows)
+            end
+            result = main_result
+          end
+          printer = showplan_printer.new(result)
+          printer.pp
+        end
+
+        # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+        def jdbc_connection_class(_spec)
+          ::ActiveRecord::ConnectionAdapters::MSSQLJdbcConnection
+        end
+
+        # Override
+        # Since we aren't passing dates/times around as strings we need to
+        # process them here, just making sure they are a string
+        def quoted_date(value)
+          super.to_s
+        end
+
+        # @Override
+        def reset!
+          clear_cache!
+          reset_transaction
+          @connection.rollback # Have to deal with rollbacks differently than the SQLServer gem
+          @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
+        end
+
+        protected
+
+        # Called to set any connection specific settings that aren't defined ahead of time
+        def configure_connection
+          # For sql server 2008+ we want it to send an actual time otherwise comparisons with time columns don't work
+          @connection.connection.setSendTimeAsDatetime(false)
+        end
+
+        # @Overwrite
+        # Makes a connection before configuring it
+        # @connection actually gets defined and then the connect method in the sqlserver gem overrides it
+        # This can probably be fixed with a patch to the main gem
+        def connect
+          @spid = @connection.execute('SELECT @@SPID').first.values.first
+          @version_year = version_year # Not sure if this is necessary but kept it this way because the gem has it this way
+          configure_connection
+        end
+
+        # @Overwrite
+        # This ends up as a no-op without the override
+        def do_execute(sql, name = 'SQL')
+          execute(sql, name)
+        end
+
+        # @Overwrite
+        # Overriding this in case it gets used in places that we don't override by default
+        def raw_connection_do(sql)
+          @connection.execute(sql)
+        ensure
+          @update_sql = false
+        end
+
+        # @Overwrite
+        def sp_executesql(sql, name, binds, _options = {})
+          exec_query(sql, name, binds)
+        end
+
+        # @Overwrite
+        # Prevents turning an insert statement into a query with results
+        # Slightly adjusted since we know there should always be a table name in the sql
+        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+          pk = primary_key(get_table_name(sql)) if pk.nil?
+          [sql, binds, pk, sequence_name]
+        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)
+          return value.quoted if value.is_a?(SQLServer::CoreExt::Time) || value.is_a?(SQLServer::CoreExt::DateTime)
+          super
+        end
+
+        def process_execute_procedure_result(result)
+          result.map do |row|
+            obj = row.with_indifferent_access
+            yield(obj) if block_given?
+            obj
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module Quoting
+
+        QUOTED_TRUE  = '1'.freeze
+        QUOTED_FALSE = '0'.freeze
+        QUOTED_STRING_PREFIX = 'N'.freeze
+
+        def fetch_type_metadata(sql_type, sqlserver_options = {})
+          cast_type = lookup_cast_type(sql_type)
+          SQLServer::SqlTypeMetadata.new(
+            sql_type: sql_type,
+            type: cast_type.type,
+            limit: cast_type.limit,
+            precision: cast_type.precision,
+            scale: cast_type.scale,
+            sqlserver_options: sqlserver_options
+          )
+        end
+
+        def quote_string(s)
+          SQLServer::Utils.quote_string(s)
+        end
+
+        def quote_string_single(s)
+          SQLServer::Utils.quote_string_single(s)
+        end
+
+        def quote_string_single_national(s)
+          SQLServer::Utils.quote_string_single_national(s)
+        end
+
+        def quote_column_name(name)
+          SQLServer::Utils.extract_identifiers(name).quoted
+        end
+
+        def quote_default_expression(value, column)
+          cast_type = lookup_cast_type(column.sql_type)
+          if cast_type.type == :uuid && value =~ /\(\)/
+            value
+          else
+            super
+          end
+        end
+
+        def quoted_true
+          QUOTED_TRUE
+        end
+
+        def unquoted_true
+          1
+        end
+
+        def quoted_false
+          QUOTED_FALSE
+        end
+
+        def unquoted_false
+          0
+        end
+
+        def quoted_date(value)
+          if value.acts_like?(:date)
+            Type::Date.new.serialize(value)
+          else value.acts_like?(:time)
+            Type::DateTime.new.serialize(value)
+          end
+        end
+
+
+        private
+
+        def _quote(value)
+          case value
+          when Type::Binary::Data
+            "0x#{value.hex}"
+          when ActiveRecord::Type::SQLServer::Data
+            value.quoted
+          when String, ActiveSupport::Multibyte::Chars
+            "#{QUOTED_STRING_PREFIX}#{super}"
+          else
+            super
+          end
+        end
+
+        def _type_cast(value)
+          case value
+          when ActiveRecord::Type::SQLServer::Data
+            value.to_s
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      class SchemaCreation < AbstractAdapter::SchemaCreation
+
+        private
+
+        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
+            select_into = "SELECT #{projections} INTO #{table_name} FROM #{source}"
+          else
+            o.instance_variable_set :@as, nil
+            super
+          end
+        end
+
+        def action_sql(action, dependency)
+          case dependency
+          when :restrict
+            raise ArgumentError, <<-MSG.strip_heredoc
+              '#{dependency}' is not supported for :on_update or :on_delete.
+              Supported values are: :nullify, :cascade
+            MSG
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module SchemaDumper
+
+        private
+
+        def schema_collation(column)
+          return unless column.collation
+          column.collation if column.collation != collation
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,517 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module SchemaStatements
+
+        def native_database_types
+          @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!
+          res
+        end
+
+        def drop_table(table_name, options = {})
+          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
+          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|
+                column.strip!
+                column.gsub! '(-)', '' if column.ends_with?('(-)')
+                column
+              end
+              indexes << IndexDefinition.new(table_name, name, unique, columns, nil, nil, where)
+            end
+          end
+        end
+
+        def columns(table_name)
+          return [] if table_name.blank?
+          column_definitions(table_name).map do |ci|
+            sqlserver_options = ci.slice :ordinal_position, :is_primary, :is_identity
+            sql_type_metadata = fetch_type_metadata ci[:type], sqlserver_options
+            new_column(
+              ci[:name],
+              ci[:default_value],
+              sql_type_metadata,
+              ci[:null],
+              ci[:table_name],
+              ci[:default_function],
+              ci[:collation],
+              nil,
+              sqlserver_options
+            )
+          end
+        end
+
+        def new_column(name, default, sql_type_metadata, null, table_name, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
+          SQLServerColumn.new(
+            name,
+            default,
+            sql_type_metadata,
+            null, table_name,
+            default_function,
+            collation,
+            comment,
+            sqlserver_options
+          )
+        end
+
+        def primary_keys(table_name)
+          primaries = schema_cache.columns(table_name).select(&:is_primary?).map(&:name)
+          primaries.present? ? primaries : identity_columns(table_name).map(&: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)
+        end
+
+        def remove_column(table_name, column_name, type = nil, options = {})
+          raise ArgumentError.new('You must specify at least one column name.  Example: remove_column(:people, :first_name)') if column_name.is_a? Array
+          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)}"
+        end
+
+        def change_column(table_name, column_name, type, options = {})
+          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)
+            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)}"
+          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) }
+        end
+
+        def change_column_default(table_name, column_name, default_or_changes)
+          clear_cache!
+          column = column_for(table_name, column_name)
+          return unless column
+          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)}"
+          clear_cache!
+        end
+
+        def rename_column(table_name, column_name, new_column_name)
+          clear_cache!
+          identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{column_name}")
+          execute_procedure :sp_rename, identifier.quoted, new_column_name, 'COLUMN'
+          rename_column_indexes(table_name, column_name, new_column_name)
+          clear_cache!
+        end
+
+        def rename_index(table_name, old_name, new_name)
+          raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{allowed_index_name_length} characters" if new_name.length > allowed_index_name_length
+          identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{old_name}")
+          execute_procedure :sp_rename, identifier.quoted, new_name, 'INDEX'
+        end
+
+        def remove_index!(table_name, index_name)
+          do_execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
+        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']
+            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
+          end
+        end
+
+        def extract_foreign_key_action(action, fk_name)
+          case select_value("SELECT #{action}_referential_action_desc FROM sys.foreign_keys WHERE name = '#{fk_name}'")
+          when 'CASCADE' then :cascade
+          when 'SET_NULL' then :nullify
+          end
+        end
+
+        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 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.")
+            end
+          when 'datetime2'
+            column_type_sql = super
+            if precision
+              if (0..7) === precision
+                column_type_sql << "(#{precision})"
+              else
+                raise(ActiveRecordError, "The dattime2 type has precision of #{precision}. The allowed range of precision is from 0 to 7")
+              end
+            end
+            column_type_sql
+          else
+            super
+          end
+        end
+
+        def columns_for_distinct(columns, orders)
+          order_columns = orders.reject(&:blank?).map{ |s|
+              s = s.to_sql unless s.is_a?(String)
+              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(', ')
+        end
+
+        def update_table_definition(table_name, base)
+          SQLServer::Table.new(table_name, base)
+        end
+
+        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
+          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 << ' NOT NULL' if !allow_null.nil? && allow_null == false
+          do_execute sql
+        end
+
+
+        protected
+
+        # === SQLServer Specific ======================================== #
+
+        def initialize_native_database_types
+          {
+            primary_key: 'int 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' },
+            boolean: { name: 'bit' },
+            decimal: { name: 'decimal' },
+            money: { name: 'money' },
+            smallmoney: { name: 'smallmoney' },
+            float: { name: 'float' },
+            real: { name: 'real' },
+            date: { name: 'date' },
+            datetime: { name: 'datetime' },
+            datetime2: { name: 'datetime2' },
+            datetimeoffset: { name: 'datetimeoffset' },
+            smalldatetime: { name: 'smalldatetime' },
+            timestamp: { name: 'datetime' },
+            time: { name: 'time' },
+            char: { name: 'char' },
+            varchar: { name: 'varchar', limit: 8000 },
+            varchar_max: { name: 'varchar(max)' },
+            text_basic: { name: 'text' },
+            nchar: { name: 'nchar' },
+            string: { name: 'nvarchar', limit: 4000 },
+            text: { name: 'nvarchar(max)' },
+            ntext: { name: 'ntext' },
+            binary_basic: { name: 'binary' },
+            varbinary: { name: 'varbinary', limit: 8000 },
+            binary: { name: 'varbinary(max)' },
+            uuid: { name: 'uniqueidentifier' },
+            ss_timestamp: { name: 'timestamp' },
+            json: { name: 'nvarchar(max)' }
+          }
+        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
+          database    = identifier.fully_qualified_database_quoted
+          view_exists = view_exists?(table_name)
+          view_tblnm  = view_table_name(table_name) if view_exists
+          sql = %{
+            SELECT DISTINCT
+            #{lowercase_schema_reflection_sql('columns.TABLE_NAME')} AS table_name,
+            #{lowercase_schema_reflection_sql('columns.COLUMN_NAME')} AS name,
+            columns.DATA_TYPE AS type,
+            columns.COLUMN_DEFAULT AS default_value,
+            columns.NUMERIC_SCALE AS numeric_scale,
+            columns.NUMERIC_PRECISION AS numeric_precision,
+            columns.DATETIME_PRECISION AS datetime_precision,
+            columns.COLLATION_NAME AS [collation],
+            columns.ordinal_position,
+            CASE
+              WHEN columns.DATA_TYPE IN ('nchar','nvarchar','char','varchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
+              ELSE COL_LENGTH('#{database}.'+columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
+            END AS [length],
+            CASE
+              WHEN columns.IS_NULLABLE = 'YES' THEN 1
+              ELSE NULL
+            END AS [is_nullable],
+            CASE
+              WHEN KCU.COLUMN_NAME IS NOT NULL AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' THEN 1
+              ELSE NULL
+            END AS [is_primary],
+            c.is_identity AS [is_identity]
+            FROM #{database}.INFORMATION_SCHEMA.COLUMNS columns
+            LEFT OUTER JOIN #{database}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
+              ON TC.TABLE_NAME = columns.TABLE_NAME
+              AND TC.TABLE_SCHEMA = columns.TABLE_SCHEMA
+              AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
+            LEFT OUTER JOIN #{database}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
+              ON KCU.COLUMN_NAME = columns.COLUMN_NAME
+              AND KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
+              AND KCU.CONSTRAINT_CATALOG = TC.CONSTRAINT_CATALOG
+              AND KCU.CONSTRAINT_SCHEMA = TC.CONSTRAINT_SCHEMA
+            INNER JOIN #{database}.sys.schemas AS s
+              ON s.name = columns.TABLE_SCHEMA
+              AND s.schema_id = s.schema_id
+            INNER JOIN #{database}.sys.objects AS o
+              ON s.schema_id = o.schema_id
+              AND o.is_ms_shipped = 0
+              AND o.type IN ('U', 'V')
+              AND o.name = columns.TABLE_NAME
+            INNER JOIN #{database}.sys.columns AS c
+              ON o.object_id = c.object_id
+              AND c.name = columns.COLUMN_NAME
+            WHERE columns.TABLE_NAME = #{prepared_statements ? COLUMN_DEFINITION_BIND_STRING_0 : quote(identifier.object)}
+              AND columns.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : (prepared_statements ? COLUMN_DEFINITION_BIND_STRING_1 : quote(identifier.schema))}
+            ORDER BY columns.ordinal_position
+          }.gsub(/[ \t\r\n]+/, ' ').strip
+
+          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
+
+          results = sp_executesql(sql, 'SCHEMA', binds)
+          results.map do |ci|
+            ci = ci.symbolize_keys
+            ci[:_type] = ci[:type]
+            ci[:table_name] = view_tblnm || table_name
+            ci[:type] = case ci[:type]
+                        when /^bit|image|text|ntext|datetime$/
+                          ci[:type]
+                        when /^datetime2|datetimeoffset$/i
+                          "#{ci[:type]}(#{ci[:datetime_precision]})"
+                        when /^time$/i
+                          "#{ci[:type]}(#{ci[:datetime_precision]})"
+                        when /^numeric|decimal$/i
+                          "#{ci[:type]}(#{ci[:numeric_precision]},#{ci[:numeric_scale]})"
+                        when /^float|real$/i
+                          "#{ci[:type]}"
+                        when /^char|nchar|varchar|nvarchar|binary|varbinary|bigint|int|smallint$/
+                          ci[:length].to_i == -1 ? "#{ci[:type]}(max)" : "#{ci[:type]}(#{ci[:length]})"
+                        else
+                          ci[:type]
+                        end
+            ci[:default_value],
+            ci[:default_function] = begin
+              default = ci[:default_value]
+              if default.nil? && view_exists
+                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'
+              end
+              case default
+              when nil
+                [nil, nil]
+              when /\A\((\w+\(\))\)\Z/
+                default_function = Regexp.last_match[1]
+                [nil, default_function]
+              when /\A\(N'(.*)'\)\Z/m
+                string_literal = SQLServer::Utils.unquote_string(Regexp.last_match[1])
+                [string_literal, nil]
+              when /CREATE DEFAULT/mi
+                [nil, nil]
+              else
+                type = case ci[:type]
+                       when /smallint|int|bigint/ then ci[:_type]
+                       else ci[:type]
+                       end
+                value = default.match(/\A\((.*)\)\Z/m)[1]
+                value = select_value "SELECT CAST(#{value} AS #{type}) AS value", 'SCHEMA'
+                [value, nil]
+              end
+            end
+            ci[:null] = ci[:is_nullable].to_i == 1
+            ci.delete(:is_nullable)
+            ci[:is_primary] = ci[:is_primary].to_i == 1
+            ci[:is_identity] = ci[:is_identity].to_i == 1 unless [TrueClass, FalseClass].include?(ci[:is_identity].class)
+            ci
+          end
+        end
+
+        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)}"
+          end
+        end
+
+        def remove_default_constraint(table_name, column_name)
+          # If their are foreign keys in this table, we could still get back a 2D array, so flatten just in case.
+          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']}"
+          end
+        end
+
+        def remove_indexes(table_name, column_name)
+          indexes(table_name).select { |index| index.columns.include?(column_name.to_s) }.each do |index|
+            remove_index(table_name, name: index.name)
+          end
+        end
+
+        # === SQLServer Specific (Misc Helpers) ========================= #
+
+        def get_table_name(sql)
+          tn = if sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)(\s+INTO)?\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
+            Regexp.last_match[3] || Regexp.last_match[4]
+          elsif sql =~ /FROM\s+([^\(\s]+)\s*/i
+            Regexp.last_match[1]
+          else
+            nil
+          end
+          SQLServer::Utils.extract_identifiers(tn).object
+        end
+
+        def default_constraint_name(table_name, column_name)
+          "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
+
+        # === SQLServer Specific (View Reflection) ====================== #
+
+        def view_table_name(table_name)
+          view_info = view_information(table_name)
+          view_info ? get_table_name(view_info['VIEW_DEFINITION']) : table_name
+        end
+
+        def view_information(table_name)
+          @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'
+            if view_info
+              view_info = view_info.with_indifferent_access
+              if view_info[:VIEW_DEFINITION].blank? || view_info[:VIEW_DEFINITION].length == 4000
+                view_info[:VIEW_DEFINITION] = begin
+                  select_values("EXEC sp_helptext #{identifier.object_quoted}", 'SCHEMA').join
+                rescue
+                  warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
+                  nil
+                end
+              end
+            end
+            view_info
+          end
+        end
+
+        def views_real_column_name(table_name, column_name)
+          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 ? match_data[1] : column_name
+        end
+
+        private
+
+        def create_table_definition(*args)
+          SQLServer::TableDefinition.new(*args)
+        end
+
+      end
+    end
+  end
+end