Implement very clean national/unicode column quoting by creating a #quoted_utf8_value method hooked into #quote. Add many tests for making sure sql types are correct with correct limiting in columns for all different types. Bump to first release version 2.2.0.

Author: metaskills

2000-2005-adapter.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "2000-2005-adapter"
-  s.version  = "1.0.1"
-  s.date     = "2008-11-19"
+  s.version  = "2.2.0"
+  s.date     = "2008-11-21"
   s.summary  = "SQL Server 2000 & 2005 Adapter For Rails."
   s.email    = "ken@metaskills.net"
   s.homepage = "http://github.com/rails-sqlserver/2000-2005-adapter/"
@@ -37,11 +37,12 @@ Gem::Specification.new do |s|
     "test/cases/schema_dumper_test_sqlserver.rb",
     "test/cases/specific_schema_test_sqlserver.rb",
     "test/cases/sqlserver_helper.rb",
+    "test/cases/table_name_test_sqlserver.rb"
+    "test/cases/unicode_test_sqlserver.rb",
     "test/connections/native_sqlserver/connection.rb",
     "test/connections/native_sqlserver_odbc/connection.rb",
     "test/migrations/transaction_table/1_table_will_never_be_created.rb",
-    "test/schema/sqlserver_specific_schema.rb",
-    "test/schema/table_name_test_sqlserver.rb" ]
+    "test/schema/sqlserver_specific_schema.rb" ]
   s.rdoc_options = ["--line-numbers", "--inline-source", "--main", "README.rdoc"]
   s.extra_rdoc_files = ["README.rdoc"]
 end

README.rdoc

@@ -14,7 +14,43 @@ The SQL Server adapter for rails is back for ActiveRecord 2.2 and up! We are cur
 * Enabled #case_sensitive_equality_operator used by unique validations.
 * Unicode character support for nchar, nvarchar and ntext data types.
 
-==== Native Text Data Type Accessor
+==== Date/Time Data Type Hinting
+
+Both SQL Server 2000 and 2005 do not have native data types for just 'date' or 'time', it only has 'datetime'. To pass the ActiveRecord tests we implemented two simple class methods that can teach your models to coerce column information to be cast correctly. Simply past a list of symbols to either the <tt>coerce_sqlserver_date</tt> or <tt>coerce_sqlserver_time</tt> methods that correspond to 'datetime' columns that need to be cast correctly.
+
+  class Topic < ActiveRecord::Base
+    coerce_sqlserver_date :last_read
+    coerce_sqlserver_time :bonus_time
+  end
+
+This implementation has some limitations. To date we can only coerce date/time types for models that conform to the expected ActiveRecord class to table naming convention. So a table of 'foo_bar_widgets' will look for coerced types in the FooBarWidget class if it exists.
+
+==== Native Data Type Support
+
+Currently the following custom data types have been tested for schema definitions.
+
+* char
+* nchar
+* nvarchar
+* ntext
+* varchar(max) for SQL Server 2005 only.
+* nvarchar(max) for SQL Server 2005 only.
+
+For example:
+
+  create_table :sql_server_custom_types, :force => true do |t|
+    t.column :ten_code,       :char,      :limit => 10
+    t.column :ten_code_utf8,  :nchar,     :limit => 10
+    t.column :title_utf8,     :nvarchar
+    t.column :body,           :varchar_max    # Creates varchar(max)
+    t.column :body_utf8,      :ntext
+    t.column :body2_utf8,     :nvarchar_max   # Creates nvarchar(max)
+  end
+
+Manually creating a varchar(max) on SQL Server 2005 is not necessary since this is the default type created when specifying a :text field. As time goes on we will be testing other SQL Server specific data types are handled correctly when created in a migration.
+
+
+==== Native Text/Binary Data Type Accessor
 
 To pass the ActiveRecord tests we had to implement an class accessor for the native type created for :text columns. By default any :text column created by migrations will create these native types.
 
@@ -25,16 +61,10 @@ During testing this type is set to 'varchar(8000)' for both versions. The reason
 
   ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'varchar(8000)'
 
-==== Date/Time Data Type Hinting
-
-Both SQL Server 2000 and 2005 do not have native data types for just 'date' or 'time', it only has 'datetime'. To pass the ActiveRecord tests we implemented two simple class methods that can teach your models to coerce column information to be cast correctly. Simply past a list of symbols to either the <tt>coerce_sqlserver_date</tt> or <tt>coerce_sqlserver_time</tt> methods that correspond to 'datetime' columns that need to be cast correctly.
+By default any :binary column created by migrations will create these native types
 
-  class Topic < ActiveRecord::Base
-    coerce_sqlserver_date :last_read
-    coerce_sqlserver_time :bonus_time
-  end
-
-This implementation has some limitations. To date we can only coerce date/time types for models that conform to the expected ActiveRecord class to table naming convention. So a table of 'foo_bar_widgets' will look for coerced types in the FooBarWidget class if it exists.
+* SQL Server 2000 is 'image'
+* SQL Server 2005 is 'varbinary(max)'
 
 
 == Versions

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -61,7 +61,7 @@ def is_special?
       end
 
       def is_utf8?
-        sql_type =~ /nvarchar|ntext|nchar|nvarchar(max)/i
+        sql_type =~ /nvarchar|ntext|nchar/i
       end
 
       def table_name
@@ -77,10 +77,16 @@ def table_klass
 
       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
+        when /^smallint/i
+          2
+        when /^int/i
+          4
+        when /^bigint/i
+          8
+        when /\(max\)/, /decimal/, /numeric/
+          nil
+        else
+          super
         end
       end
 
@@ -146,14 +152,14 @@ 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
+      LIMITABLE_TYPES         = ['string','integer','float','char','nchar','varchar','nvarchar'].freeze
 
-      cattr_accessor :native_text_database_type
+      cattr_accessor :native_text_database_type, :native_binary_database_type
 
       class << self
 
         def type_limitable?(type)
-          LIMITABLE_TYPES.include?(type.to_sym)
+          LIMITABLE_TYPES.include?(type.to_s)
         end
 
       end
@@ -205,11 +211,22 @@ def native_text_database_type
         self.class.native_text_database_type || (sqlserver_2005? ? 'varchar(max)' : 'text')
       end
 
+      def native_binary_database_type
+        self.class.native_binary_database_type || (sqlserver_2005? ? 'varbinary(max)' : 'image')
+      end
+      
       # QUOTING ==================================================#
 
       def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary
-          column.class.string_to_binary(value)
+        case value
+        when String, ActiveSupport::Multibyte::Chars
+          if column && column.type == :binary
+            column.class.string_to_binary(value)
+          elsif column && column.respond_to?(:is_utf8?) && column.is_utf8?
+            quoted_utf8_value(value)
+          else
+            super
+          end
         else
           super
         end
@@ -244,6 +261,10 @@ def quoted_date(value)
         end
       end
 
+      def quoted_utf8_value(value)
+        "N'#{quote_string(value)}'"
+      end
+      
       # REFERENTIAL INTEGRITY ====================================#
 
       def disable_referential_integrity(&block)
@@ -394,20 +415,26 @@ def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
       # SCHEMA STATEMENTS ========================================#
 
       def native_database_types
-        binary = sqlserver_2005? ? "varbinary(max)" : "image"
         {
-          :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
-          :string      => { :name => "varchar", :limit => 255  },
-          :text        => { :name =>  native_text_database_type },
-          :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 =>  binary },
-          :boolean     => { :name => "bit"}
+          :primary_key  => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
+          :string       => { :name => "varchar", :limit => 255  },
+          :text         => { :name =>  native_text_database_type },
+          :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 =>  native_binary_database_type },
+          :boolean      => { :name => "bit"},
+          # These are custom types that may move somewhere else for good schema_dumper.rb hacking to output them.
+          :char         => { :name => 'char' },
+          :varchar_max  => { :name => 'varchar(max)' },
+          :nchar        => { :name => "nchar" },
+          :nvarchar     => { :name => "nvarchar", :limit => 255 },
+          :nvarchar_max => { :name => "nvarchar(max)" },
+          :ntext        => { :name => "ntext" }
         }
       end
 
@@ -505,7 +532,8 @@ def remove_index(table_name, options = {})
 
       def type_to_sql(type, limit = nil, precision = nil, scale = nil)
         limit = nil unless self.class.type_limitable?(type)
-        if type.to_s == 'integer'
+        case type.to_s
+        when 'integer'
           case limit
             when 1..2       then  'smallint'
             when 3..4, nil  then  'integer'
@@ -606,12 +634,10 @@ def select(sql, name = nil, ignore_special_columns = false)
       end
 
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        set_utf8_values!(sql)
         super || select_value("SELECT SCOPE_IDENTITY() AS Ident")
       end
 
       def update_sql(sql, name = nil)
-        set_utf8_values!(sql)
         execute(sql, name)
         select_value('SELECT @@ROWCOUNT AS AffectedRows')
       end
@@ -794,11 +820,9 @@ def remove_sqlserver_columns_cache_for(table_name)
       def column_definitions(table_name)
         db_name = unqualify_db_name(table_name)
         table_name = unqualify_table_name(table_name)
-        # COL_LENGTH returns values that do not reflect how much data can be stored in certain data types.
-        # COL_LENGTH returns -1 for varchar(max), nvarchar(max), and varbinary(max)
-        # COL_LENGTH returns 16 for ntext, text, image types
         sql = %{
           SELECT
+          columns.TABLE_NAME as table_name,
           columns.COLUMN_NAME as name,
           columns.DATA_TYPE as type,
           CASE
@@ -808,10 +832,7 @@ def column_definitions(table_name)
           columns.NUMERIC_SCALE as numeric_scale,
           columns.NUMERIC_PRECISION as numeric_precision,
           CASE
-            WHEN columns.DATA_TYPE IN ('nvarchar') AND COL_LENGTH(columns.TABLE_NAME, columns.COLUMN_NAME) = -1 THEN 1073741823
-            WHEN columns.DATA_TYPE IN ('varchar', 'varbinary') AND COL_LENGTH(columns.TABLE_NAME, columns.COLUMN_NAME) = -1 THEN 2147483647
-            WHEN columns.DATA_TYPE IN ('ntext') AND COL_LENGTH(columns.TABLE_NAME, columns.COLUMN_NAME) = 16 THEN 1073741823
-            WHEN columns.DATA_TYPE IN ('text', 'image') AND COL_LENGTH(columns.TABLE_NAME, columns.COLUMN_NAME) = 16 THEN 2147483647
+            WHEN columns.DATA_TYPE IN ('nchar','nvarchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
             ELSE COL_LENGTH(columns.TABLE_NAME, columns.COLUMN_NAME) 
           END as length,
           CASE
@@ -829,12 +850,16 @@ def column_definitions(table_name)
         results = without_type_conversion { select(sql,nil,true) }
         results.collect do |ci|
           ci.symbolize_keys!
-          ci[:type] = if ci[:type] =~ /numeric|decimal/i
+          ci[:type] = case ci[:type]
+                      when /^bit|image|text|ntext|datetime$/
+                        ci[:type]
+                      when /^numeric|decimal$/i
                         "#{ci[:type]}(#{ci[:numeric_precision]},#{ci[:numeric_scale]})"
+                      when /^char|nchar|varchar|nvarchar|varbinary|bigint|int|smallint$/
+                        ci[:length].to_i == -1 ? "#{ci[:type]}(max)" : "#{ci[:type]}(#{ci[:length]})"
                       else
-                        "#{ci[:type]}(#{ci[:length]})"
+                        ci[:type]
                       end
-          ci[:table_name] = table_name
           ci[:default_value] = ci[:default_value].match(/\A\(+N?'?(.*?)'?\)+\Z/)[1] if ci[:default_value]
           ci[:null] = ci[:is_nullable].to_i == 1 ; ci.delete(:is_nullable)
           ci
@@ -848,8 +873,6 @@ def column_for(table_name, column_name)
         column
       end
 
-      
-      
       def change_order_direction(order)
         order.split(",").collect {|fragment|
           case fragment
@@ -859,11 +882,11 @@ def change_order_direction(order)
           end
         }.join(",")
       end
-
+      
       def special_columns(table_name)
         columns(table_name).select(&:is_special?).map(&:name)
       end
-
+      
       def repair_special_columns(sql)
         special_cols = special_columns(get_table_name(sql))
         for col in special_cols.to_a
@@ -872,35 +895,7 @@ def repair_special_columns(sql)
         end
         sql
       end
-
-      def utf8_columns(table_name)
-        columns(table_name).select(&:is_utf8?).map(&:name)
-      end
-      
-      def set_utf8_values!(sql)
-        utf8_cols = utf8_columns(get_table_name(sql))
-        if sql =~ /^\s*UPDATE/i
-          utf8_cols.each do |col|
-            sql.gsub!("[#{col.to_s}] = '", "[#{col.to_s}] = N'")
-          end
-        elsif sql =~ /^\s*INSERT(?!.*DEFAULT VALUES\s*$)/i
-          # TODO This code should be simplified
-          # Get columns and values, split them into arrays, and store the original_values for when we need to replace them
-          columns_and_values = sql.scan(/\((.*?)\)/m).flatten
-          columns = columns_and_values.first.split(',')
-          values =  columns_and_values[1].split(',')
-          original_values = values.dup
-          # Iterate columns that should be UTF8, and append an N to the value, if the value is not NULL
-          utf8_cols.each do |col|
-            columns.each_with_index do |column, idx|
-              values[idx] = " N#{values[idx].gsub(/^ /, '')}" if column =~ /\[#{col}\]/ and values[idx] !~ /^NULL$/
-            end
-          end
-          # Replace (in place) the SQL
-          sql.gsub!(original_values.join(','), values.join(','))
-        end
-      end
-      
+            
     end #class SQLServerAdapter < AbstractAdapter
 
   end #module ConnectionAdapters

test/cases/adapter_test_sqlserver.rb

@@ -215,33 +215,6 @@ def setup
 
     end
 
-    context 'which have coerced types' do
-      
-      setup do
-        christmas_08 = "2008-12-25".to_time
-        christmas_08_afternoon = "2008-12-25 12:00".to_time
-        @chronic_date = SqlServerChronic.create!(:date => christmas_08).reload
-        @chronic_time = SqlServerChronic.create!(:time => christmas_08_afternoon).reload
-      end
-      
-      should 'have an inheritable attribute ' do
-        assert SqlServerChronic.coerced_sqlserver_date_columns.include?('date')
-      end
-      
-      should 'have column and objects cast to date' do
-        date_column = SqlServerChronic.columns_hash['date']
-        assert_equal :date, date_column.type, "This column: \n#{date_column.inspect}"
-        assert_instance_of Date, @chronic_date.date
-      end
-      
-      should 'have column objects cast to time' do
-        time_column = SqlServerChronic.columns_hash['time']
-        assert_equal :time, time_column.type, "This column: \n#{time_column.inspect}"
-        assert_instance_of Time, @chronic_time.time
-      end
-      
-    end
-    
   end
 
   context 'For identity inserts' do