Make sure basic Rails types match up in schema statements.

Author: metaskills

lib/active_record/connection_adapters/sqlserver/schema_creation.rb

@@ -2,6 +2,7 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       class SchemaCreation < AbstractAdapter::SchemaCreation
+
         private
 
         def visit_ColumnDefinition(o)
@@ -50,6 +51,7 @@ def visit_TableDefinition(o)
 
           create_sql
         end
+
       end
     end
   end

lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -168,7 +168,7 @@ def initialize_native_database_types
             decimal: { name: 'decimal' },
             money: { name: 'money' },
             smallmoney: { name: 'smallmoney' },
-            float: { name: 'float', limit: 8 },
+            float: { name: 'float', limit: 24 },
             real: { name: 'real' },
             date: { name: 'date' },
             datetime: { name: 'datetime' },
@@ -402,7 +402,6 @@ def strip_ident_from_update(sql)
           # There has to be a better way to handle this, but this'll do for now.
           table_name = get_table_name(sql)
           id_column = identity_column(table_name)
-
           if id_column
             regex_col_name = Regexp.quote(quote_column_name(id_column.name))
             if sql =~ /, #{regex_col_name} = @?[0-9]*/
@@ -437,10 +436,11 @@ def identity_column(table_name)
           schema_cache.columns(table_name).find(&:is_identity?)
         end
 
+
         private
 
         def create_table_definition(name, temporary, options, as = nil)
-          TableDefinition.new native_database_types, name, temporary, options, as
+          SQLServer::TableDefinition.new native_database_types, name, temporary, options, as
         end
 
       end

lib/active_record/connection_adapters/sqlserver/table_definition.rb

@@ -2,6 +2,7 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+
         def uuid(name, options = {})
           column(name, 'uniqueidentifier', options)
         end
@@ -13,10 +14,6 @@ def primary_key(name, type = :primary_key, options = {})
           column name, type, options
         end
 
-        def column(name, type = nil, options = {})
-          super
-          self
-        end
       end
     end
   end

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

@@ -4,7 +4,9 @@ module SQLServer
       module Type
         class BigInteger < Integer
 
-
+          def type
+            :bigint
+          end
 
         end
       end

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

@@ -6,6 +6,11 @@ class Float < ActiveRecord::Type::Float
 
           include Castable
 
+          def initialize(options = {})
+            super
+            @limit ||= 24
+          end
+
         end
       end
     end

test/cases/adapter_test_sqlserver.rb

@@ -333,7 +333,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'create floats when no limit supplied' do
-      assert_equal 'float(8)', connection.type_to_sql(:float)
+      assert_equal 'float(24)', connection.type_to_sql(:float)
     end
 
     it 'create floats when limit is supplied' do

test/cases/column_test_sqlserver.rb

@@ -37,7 +37,7 @@ def assert_obj_set_and_save(attribute, value)
       col.default_function.must_equal   nil
       type = col.cast_type
       type.must_be_instance_of          Type::BigInteger
-      type.type.must_equal              :integer
+      type.type.must_equal              :bigint
       type.must_be                      :number?
       type.limit.must_equal             8
       assert_obj_set_and_save :bigint, -9_223_372_036_854_775_808

test/cases/schema_dumper_test_sqlserver.rb

@@ -10,7 +10,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
   it 'sst_datatypes' do
     generate_schema_for_table 'sst_datatypes'
     # Exact Numerics
-    assert_line :bigint,        type: 'integer',      limit: '8',           precision: nil,   scale: nil,  default: '42'
+    assert_line :bigint,        type: 'bigint',       limit: '8',           precision: nil,   scale: nil,  default: '42'
     assert_line :int,           type: 'integer',      limit: '4',           precision: nil,   scale: nil,  default: '42'
     assert_line :smallint,      type: 'integer',      limit: '2',           precision: nil,   scale: nil,  default: '42'
     assert_line :tinyint,       type: 'integer',      limit: '1',           precision: nil,   scale: nil,  default: '42'
@@ -46,6 +46,38 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :varbinary_max, type: 'binary',       limit: '2147483647',  precision: nil,   scale: nil,  default: nil
   end
 
+  it 'sst_datatypes_migration' do
+    columns = SSTestDatatypeMigration.columns_hash
+    generate_schema_for_table 'sst_datatypes_migration'
+    # Simple Rails conventions
+    columns['integer_col'].sql_type.must_equal    'int(4)'
+    columns['bigint_col'].sql_type.must_equal     'bigint(8)'
+    columns['boolean_col'].sql_type.must_equal    'bit'
+    columns['decimal_col'].sql_type.must_equal    'decimal(18,0)'
+    columns['float_col'].sql_type.must_equal      'real(24)'
+    columns['string_col'].sql_type.must_equal     'nvarchar(4000)'
+    columns['text_col'].sql_type.must_equal       'nvarchar(max)'
+    columns['datetime_col'].sql_type.must_equal   'datetime'
+    columns['timestamp_col'].sql_type.must_equal  'datetime'
+    columns['time_col'].sql_type.must_equal       'time(7)'
+    columns['date_col'].sql_type.must_equal       'date'
+    columns['binary_col'].sql_type.must_equal     'varbinary(max)'
+    assert_line :integer_col,   type: 'integer',  limit: '4',          precision: nil,  scale: nil, default: nil
+    assert_line :bigint_col,    type: 'bigint',   limit: '8',          precision: nil,  scale: nil, default: nil
+    assert_line :boolean_col,   type: 'boolean',  limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :decimal_col,   type: 'decimal',  limit: nil,          precision: '18', scale: '0', default: nil
+    assert_line :float_col,     type: 'real',     limit: '24',         precision: nil,  scale: nil, default: nil
+    assert_line :string_col,    type: 'string',   limit: '4000',       precision: nil,  scale: nil, default: nil
+    assert_line :text_col,      type: 'text',     limit: '2147483647', precision: nil,  scale: nil, default: nil
+    assert_line :datetime_col,  type: 'datetime', limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :timestamp_col, type: 'datetime', limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :time_col,      type: 'time',     limit: nil,          precision: '7',  scale: nil, default: nil
+    assert_line :date_col,      type: 'date',     limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :binary_col,    type: 'binary',   limit: '2147483647', precision: nil,  scale: nil, default: nil
+  end
+
+  # Special Cases
+
   it 'primary_key' do
     generate_schema_for_table('movies') do |output|
       match = output.match(%r{create_table "movies"(.*)do})
@@ -54,18 +86,6 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     end
   end
 
-  it 'a string type is nvarchar without a limit' do
-    generate_schema_for_table 'sst_datatypes_migration'
-    SSTestDatatypeMigration.columns_hash['string_col'].sql_type.must_equal 'nvarchar(4000)'
-    assert_line :string_col, type: 'string', limit: '4000', precision: nil, scale: nil, default: nil
-  end
-
-  it 'a text type is nvarchar max' do
-    generate_schema_for_table 'sst_datatypes_migration'
-    SSTestDatatypeMigration.columns_hash['text_col'].sql_type.must_equal 'nvarchar(max)'
-    assert_line :text_col, type: 'text', limit: '2147483647', precision: nil, scale: nil, default: nil
-  end
-
 
   private
 
@@ -77,7 +97,7 @@ def generate_schema_for_table(*table_names)
     @generated_schema = stream.string
     yield @generated_schema if block_given?
     @schema_lines = Hash.new
-    type_matcher = /\A\s+t\.\w+\s+"(.*?)",/
+    type_matcher = /\A\s+t\.\w+\s+"(.*?)"[,\n]/
     @generated_schema.each_line do |line|
       next unless line =~ type_matcher
       @schema_lines[Regexp.last_match[1]] = SchemaLine.new(line)
@@ -91,7 +111,7 @@ def line(column_name)
 
   def assert_line(column_name, options={})
     line = line(column_name)
-    assert line, "Count not find line with column name: #{column_name.inspect}"
+    assert line, "Count not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
     line.type_method.must_equal  options[:type],      "Type of #{options[:type].inspect} not found in:\n #{line}"            if options.key?(:type)
     line.limit.must_equal        options[:limit],     "Limit of #{options[:limit].inspect} not found in:\n #{line}"          if options.key?(:limit)
     line.precision.must_equal    options[:precision], "Precision of #{options[:precision].inspect} not found in:\n #{line}"  if options.key?(:precision)

test/schema/sqlserver_specific_schema.rb

@@ -5,17 +5,29 @@
   execute File.read(ARTest::SQLServer.schema_datatypes_2012_file)
 
   create_table :sst_datatypes_migration, force: true do |t|
-    # Rails conventions
-    t.string  :string_col
-    t.text    :text_col
-    # Our type methods
+    # Simple Rails conventions.
+    t.integer   :integer_col
+    t.bigint    :bigint_col
+    t.boolean   :boolean_col
+    t.decimal   :decimal_col
+    t.float     :float_col
+    t.string    :string_col
+    t.text      :text_col
+    t.datetime  :datetime_col
+    t.timestamp :timestamp_col
+    t.time      :time_col
+    t.date      :date_col
+    t.binary    :binary_col
+
+
+    # Our type methods. Make sure we can reverse schema dump for [sst_datatypes] table.
     # ...
   end
 
   # Edge Cases
 
   create_table 'sst_my$strange_table', force: true do |t|
-    t.column :number, :real
+    t.string :name
   end
 
   create_table :SST_UPPER_TESTS, force: true do |t|