Remove direct support for :text in lieu of :varchar(8000). Now using #extract_limit vs. limitable? hack. The #type_to_sql method is now much more like PostgreSQL adapter.

Author: metaskills

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -118,7 +118,6 @@ class SQLServerColumn < Column #:nodoc:
       def initialize(name, default, sql_type = nil, null = true, sqlserver_options = {})
         super(name, default, sql_type, null)
         @sqlserver_options = sqlserver_options
-        @limit = nil unless limitable?
       end
 
       def is_identity?
@@ -205,10 +204,13 @@ def new_time(year, mon, mday, hour, min, sec, microsec = 0)
 
       private
 
-      def limitable?
-        # SQL Server only supports limits on *char and float types. Although for schema dumping purposes 
-        # it is useful to know what others are like bigint and smallint. So we trump #extract_limit.
-        [:float,:string].include?(type) || (type == :integer && sql_type =~ /^(big|small)int/i)
+      def extract_limit(sql_type)
+        case sql_type
+          when /^smallint/i   then  2
+          when /^int/i        then  4
+          when /^bigint/i     then  8
+          else super
+        end
       end
 
       def simplified_type(field_type)
@@ -271,6 +273,15 @@ class SQLServerAdapter < AbstractAdapter
       ADAPTER_NAME            = 'SQLServer'.freeze
       DATABASE_VERSION_REGEXP = /Microsoft SQL Server\s+(\d{4})/
       SUPPORTED_VERSIONS      = [2000,2005].freeze
+      LIMITABLE_TYPES         = [:string,:integer,:float].freeze
+      
+      class << self
+        
+        def type_limitable?(type)
+          LIMITABLE_TYPES.include?(type.to_sym)
+        end
+        
+      end
 
       def initialize(connection, logger, connection_options=nil)
         super(connection, logger)
@@ -464,20 +475,20 @@ def empty_insert_statement(table_name)
       # SCHEMA STATEMENTS ========================================#
 
       def native_database_types
-        txt = sqlserver_2005? ? "varchar(max)"   : "text"
-        bin = sqlserver_2005? ? "varbinary(max)" : "image"
+        text   = sqlserver_2005? ? "varchar(max)"   : "varchar(8000)"
+        binary = sqlserver_2005? ? "varbinary(max)" : "image"
         {
           :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
           :string      => { :name => "varchar", :limit => 255  },
-          :text        => { :name =>  txt },
-          :integer     => { :name => "int" },
+          :text        => { :name =>  text },
+          :integer     => { :name => "int", :limit => 4 },
           :float       => { :name => "float", :limit => 8 },
           :decimal     => { :name => "decimal" },
           :datetime    => { :name => "datetime" },
           :timestamp   => { :name => "datetime" },
           :time        => { :name => "datetime" },
           :date        => { :name => "datetime" },
-          :binary      => { :name =>  bin },
+          :binary      => { :name =>  binary },
           :boolean     => { :name => "bit"}
         }
       end
@@ -589,19 +600,16 @@ def add_order_by_for_association_limiting!(sql, options)
       end
 
       def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-        # Remove limit for data types which do not require it
-        # Valid:   ALTER TABLE sessions ALTER COLUMN [data] varchar(max)
-        # Invalid: ALTER TABLE sessions ALTER COLUMN [data] varchar(max)(16777215)
-        limit = nil if %w{text varchar(max) nvarchar(max) ntext varbinary(max) image}.include?(native_database_types[type.to_sym][:name])
-        return super unless type.to_s == 'integer'
-        if limit.nil?
-          'integer'
-        elsif limit > 4
-          'bigint'
-        elsif limit < 3
-          'smallint'
+        limit = nil unless self.class.type_limitable?(type)
+        if type.to_s == '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
         else
-          'integer'
+          super
         end
       end
 

test/cases/adapter_test_sqlserver.rb

@@ -196,7 +196,7 @@ def setup
   context 'For SchemaStatements' do
 
     context 'returning from #type_to_sql' do
-
+      
       should 'create integers when no limit supplied' do
         assert_equal 'integer', @connection.type_to_sql(:integer)
       end

test/cases/schema_dumper_test_sqlserver.rb

@@ -1,8 +1,5 @@
 require 'cases/sqlserver_helper'
 
-# NOTE: The existing schema_dumper_test doesn't test the limits of <4 limit things
-# for adapaters that aren't mysql, sqlite or postgres. We should. It also only tests 
-# non-standard id dumping for mysql. We'll do that too.
 class SchemaDumperTestSqlserver < ActiveRecord::TestCase
 
   context 'In schema dump' do
@@ -15,6 +12,10 @@ class SchemaDumperTestSqlserver < ActiveRecord::TestCase
       assert_match %r{c_int_4.*}, output
       assert_no_match %r{c_int_3.*:limit}, output
       assert_no_match %r{c_int_4.*:limit}, output
+      assert_match %r{c_int_5.*:limit => 8}, output
+      assert_match %r{c_int_6.*:limit => 8}, output
+      assert_match %r{c_int_7.*:limit => 8}, output
+      assert_match %r{c_int_8.*:limit => 8}, output
     end
 
     should 'honor nonstandard primary keys' do