rails-sqlserver-2000-2005-adapter 1.0.1 → 2.2.0

data/README.rdoc

@@ -1,36 +1,117 @@
 
 == Rails SQL Server 2000 & 2005 Adapter
 
-For Rails/ActiveRecord 2.2 and up. More details to come.
+The SQL Server adapter for rails is back for ActiveRecord 2.2 and up! We are currently passing all tests and hope to continue to do so moving forward. 
+
+
+== What's New
+
+* Enabled support for DDL transactions.
+* Micro second support. Time#usec is automatically converted to SQL Server's 3.33 millisecond limitation.
+* Datetime data types before type casting are represented correctly. For example: 1998-01-01 23:59:59.997
+* Implementation for #disable_referential_integrity used by ActiveRecord's Fixtures class.
+* Pessimistic locking suppot. See the #add_lock! method for details.
+* Enabled #case_sensitive_equality_operator used by unique validations.
+* Unicode character support for nchar, nvarchar and ntext data types.
+
+==== 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.
+
+* SQL Server 2000 is 'text'
+* SQL Server 2005 is 'varchar(max)'
+
+During testing this type is set to 'varchar(8000)' for both versions. The reason is that rails expects to be able to use SQL = operators on text data types and this is not possible with a native 'text' data type in SQL Server. The default 'varchar(max)' for SQL Server 2005 can be queried using the SQL = operator and has plenty of storage space which is why we made it the default for 2005. If for some reason you want to change the data type created during migrations for any SQL Server version, you can include this line in your environment.rb file.
+
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'varchar(8000)'
+
+By default any :binary column created by migrations will create these native types
+
+* SQL Server 2000 is 'image'
+* SQL Server 2005 is 'varbinary(max)'
+
+
+== Versions
+
+It is our goal to match the adapter version with each version of rails. However we will track our own tiny version independent of ActiveRecord. For example, an adapter version of 2.2.x will work on any 2.2.x version of ActiveRecord. This convention will be used in both the Git tags as well as the Rubygems versioning.
 
 
 == Installation
-  
-This method is unconfirmed. You can install the adapter as a gem using the following command. Once I confirm this I can give you an example of a config.gem command too. For now I know that rails and/or ActiveRecord expects to find the SQL Server adapter in the vendor/plugins/adapters/sqlserver folder of your rails project.
 
-  $ sudo gem install rails-sqlserver-2000-2005-adapter
+First, you will need Ruby DBI and Ruby ODBC. To my knowledge the ADO DBD for DBI is no longer supported. The installation below is not a comprehensive walk thru on how to get all the required moving parts like FreeTDS installed and/or configured. It will also assume gem installations of both the dependent libraries and the adapter itself.
 
-Ruby DBI is required and to my knowledge the ADO DBD driver is no longer supported, meaning that ODBC is the only way to go. During development ancient versions of DBI back to 0.0.23 were tested along with the current latest 0.4.0 version. Because later versions of DBI will be changing many things, IT IS HIGHLY RECOMMENDED that you install 0.4.0 which the examples below show. This is not a compressive how to since ODBC mode requires also that you install Ruby ODBC and possibly FreeTDS.
+It should be noted that this version of the adapter was developed using both the ancient 0.0.23 version of DBI up to the current stable release of 0.4.0. Because later versions of DBI will be changing many things, IT IS HIGHLY RECOMMENDED that you max your install to version 0.4.0 which the examples below show. For the time being we are not supporting DBI versions higher than 0.4.0. The good news is that if you were using a very old DBI with ADO, technically this adapter will still work for you, but be warned your path is getting old and may not be supported for long.
 
-  $ sudo gem install dbi --version 0.4.0
-  $ sudo gem install dbd-odbc --version 0.2.4
+  $ gem install dbi --version 0.4.0
+  $ gem install dbd-odbc --version 0.2.4
+  $ gem install rails-sqlserver-2000-2005-adapter
 
 Optionally configure your gem dependencies in your rails environment.rb file.
 
   config.gem 'dbi', :version => '0.4.0'
   config.gem 'dbd-odbc', :version => '0.2.4', :lib => 'dbd/ODBC'
+  config.gem 'rails-sqlserver-2000-2005-adapter', :lib => 'active_record/connection_adapters/sqlserver_adapter'
+
+Here are some external links for libraries and/or tutorials on how to install any other additional components to use this adapter. If you know of a good one that we can include here, just let us know.
+
+* http://ruby-dbi.sourceforge.net/
+* http://www.ch-werner.de/rubyodbc/
 
 
 == Contributing
 
-Please read the RUNNING_UNIT_TESTS file for the details of how to run the unit tests. Bugs can be reported to our lighthouse page at http://rails-sqlserver.lighthouseapp.com/projects/20277-sql-server-05-adapter/overview
+If you’d like to contribute a feature or bugfix, thanks! To make sure your fix/feature has a high chance of being added, please read the following guidelines. First, ask on the Google list, IRC, or post a ticket in Lighthouse. Second, make sure there are tests! We will not accept any patch that is not tested. Please read the RUNNING_UNIT_TESTS file for the details of how to run the unit tests.
 
-There is also a #rails-sqlserver channel on irc.freenode.net if you want to discuss any topics about the adapter.
+* Lighthouse: http://rails-sqlserver.lighthouseapp.com/projects/20277-sql-server-05-adapter/overview
+* Google Group: http://groups.google.com/group/rails-sqlserver-adapter
+* IRC Room: #rails-sqlserver on irc.freenode.net
 
 
 == Credits
 
-Many many people have contributed to this over 
+Many many people have contributed. If you do not see your name here and it should be let us know.
+
+* Ken Collins
+* Murray Steele
+* Shawn Balestracci
+* Joe Rafaniello
+* Tom Ward
 
 
 == License

data/Rakefile

@@ -1,52 +1,7 @@
 require 'rubygems'
 require 'rake'
 require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
 
-PKG_NAME = 'activerecord-sqlserver-adapter'
-PKG_BUILD = (".#{ENV['PKG_BUILD']}" if ENV['PKG_BUILD'])
-PKG_VERSION = "1.0.0.314#{PKG_BUILD}"
-
-spec = Gem::Specification.new do |s|
-  s.name = PKG_NAME
-  s.summary = 'SQL Server adapter for Active Record - ABR'
-  s.version = PKG_VERSION
-
-  s.add_dependency 'activerecord', '>= 1.15.5.7843'
-  s.require_path = 'lib'
-
-  s.files = %w(lib/active_record/connection_adapters/sqlserver_adapter.rb)
-
-  s.author = 'Tom Ward'
-  s.email = 'tom@popdog.net'
-  s.homepage = 'http://wiki.rubyonrails.org/rails/pages/SQL+Server'
-  s.rubyforge_project = 'activerecord'
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-  p.gem_spec = spec
-  p.need_tar = true
-  p.need_zip = true
-end
-
-desc "Publish the beta gem"
-task :pgem => :package do
-  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_NAME}-#{PKG_VERSION}.gem").upload
-  `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
-end
-
-desc "Publish the release files to RubyForge."
-task :release => :package do
-  require 'rubyforge'
-
-  packages = %w(gem tgz zip).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
-
-  rubyforge = RubyForge.new
-  rubyforge.login
-  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
-end
 
 desc 'Create the SQL Server test databases'
 task :create_databases do
@@ -87,9 +42,3 @@ for adapter in %w( sqlserver sqlserver_odbc )
   end
 end
 
-
-desc 'Clean existing gems out'
-task :clean do
-  packages = %w(gem tgz zip).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
-  FileUtils.rm(packages, :force => true)
-end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -61,7 +61,7 @@ module ActiveRecord
       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 @@ module ActiveRecord
       
       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 @@ module ActiveRecord
       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 @@ module ActiveRecord
         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
@@ -223,6 +240,11 @@ module ActiveRecord
         column_name.to_s.split('.').map{ |name| "[#{name}]" }.join('.')
       end
       
+      def quote_table_name(table_name)
+        return table_name if table_name =~ /^\[.*\]$/
+        quote_column_name(table_name)
+      end
+      
       def quoted_true
         '1'
       end
@@ -239,6 +261,10 @@ module ActiveRecord
         end
       end
       
+      def quoted_utf8_value(value)
+        "N'#{quote_string(value)}'"
+      end
+      
       # REFERENTIAL INTEGRITY ====================================#
       
       def disable_referential_integrity(&block)
@@ -389,20 +415,26 @@ module ActiveRecord
       # 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
       
@@ -500,7 +532,8 @@ module ActiveRecord
       
       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'
@@ -601,12 +634,10 @@ module ActiveRecord
       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
@@ -789,11 +820,9 @@ module ActiveRecord
       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
@@ -803,10 +832,7 @@ module ActiveRecord
           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
@@ -824,12 +850,16 @@ module ActiveRecord
         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
@@ -843,8 +873,6 @@ module ActiveRecord
         column
       end
       
-      
-      
       def change_order_direction(order)
         order.split(",").collect {|fragment|
           case fragment
@@ -854,11 +882,11 @@ module ActiveRecord
           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
@@ -867,35 +895,7 @@ module ActiveRecord
         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

data/test/cases/adapter_test_sqlserver.rb

@@ -215,33 +215,6 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
       
     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

data/test/cases/column_test_sqlserver.rb

@@ -4,6 +4,7 @@ require 'models/binary'
 class ColumnTestSqlserver < ActiveRecord::TestCase
   
   def setup
+    @connection = ActiveRecord::Base.connection
     @column_klass = ActiveRecord::ConnectionAdapters::SQLServerColumn
   end
   
@@ -18,7 +19,16 @@ class ColumnTestSqlserver < ActiveRecord::TestCase
     end
   end
   
-  context 'For :binary columns' do
+  should 'return correct null, limit, and default for Topic' do
+    tch = Topic.columns_hash
+    assert_equal false, tch['id'].null
+    assert_equal true,  tch['title'].null
+    assert_equal 255,   tch['author_name'].limit
+    assert_equal true,  tch['approved'].default
+    assert_equal 0,     tch['replies_count'].default
+  end
+  
+  context 'For binary columns' do
 
     setup do
       @binary_string = "GIF89a\001\000\001\000\200\000\000\377\377\377\000\000\000!\371\004\000\000\000\000\000,\000\000\000\000\001\000\001\000\000\002\002D\001\000;"
@@ -29,6 +39,13 @@ class ColumnTestSqlserver < ActiveRecord::TestCase
       assert_equal @binary_string, Binary.find(@saved_bdata).data
     end
     
+    should 'have correct attributes' do
+      column = Binary.columns_hash['data']
+      assert_equal :binary, column.type
+      assert_equal @connection.native_binary_database_type, column.sql_type
+      assert_equal nil, column.limit
+    end
+    
     should 'quote data for sqlserver with literal 0x prefix' do
       # See the output of the stored procedure: 'exec sp_datatype_info'
       sqlserver_encoded_bdata = "0x47494638396101000100800000ffffff00000021f90400000000002c00000000010001000002024401003b"
@@ -37,30 +54,193 @@ class ColumnTestSqlserver < ActiveRecord::TestCase
 
   end
   
-  context 'For .columns method' do
+  context 'For string columns' do
+
+    setup do
+      @char         = SqlServerString.columns_hash['char']
+      @char10       = SqlServerString.columns_hash['char_10']
+      @varcharmax   = SqlServerString.columns_hash['varchar_max']
+      @varcharmax10 = SqlServerString.columns_hash['varchar_max_10']
+    end
 
-    should 'return correct scales and precisions for NumericData' do
-      bank_balance = NumericData.columns_hash['bank_balance']
-      big_bank_balance = NumericData.columns_hash['big_bank_balance']
-      world_population = NumericData.columns_hash['world_population']
-      my_house_population = NumericData.columns_hash['my_house_population']
-      assert_equal [2,10], [bank_balance.scale, bank_balance.precision]
-      assert_equal [2,15], [big_bank_balance.scale, big_bank_balance.precision]
-      assert_equal [0,10], [world_population.scale, world_population.precision]
-      assert_equal [0,2], [my_house_population.scale, my_house_population.precision]
-    end
-    
-    should 'return correct null, limit, and default for Topic' do
-      tch = Topic.columns_hash
-      assert_equal false, tch['id'].null
-      assert_equal true,  tch['title'].null
-      assert_equal 255,   tch['author_name'].limit
-      assert_equal true,  tch['approved'].default
-      assert_equal 0,     tch['replies_count'].default
+    should 'have correct simplified types' do
+      assert_equal :string, @char.type
+      assert_equal :string, @char10.type
+      if sqlserver_2005?
+        assert_equal :string, @varcharmax.type
+        assert_equal :string, @varcharmax10.type
+      end
+    end
+    
+    should 'have correct #sql_type per schema definition' do
+      assert_equal 'char(1)',     @char.sql_type,       'Specifing a char type with no limit is 1 by SQL Server standards.'
+      assert_equal 'char(10)',    @char10.sql_type,      @char10.inspect
+      if sqlserver_2005?
+        assert_equal 'varchar(max)', @varcharmax.sql_type,   'A -1 limit should be converted to max (max) type.'
+        assert_equal 'varchar(max)', @varcharmax10.sql_type, 'A -1 limit should be converted to max (max) type.'
+      end
+    end
+    
+    should 'have correct #limit per schema definition' do
+      assert_equal 1,   @char.limit
+      assert_equal 10,  @char10.limit
+      if sqlserver_2005?
+        assert_equal nil, @varcharmax.limit,   'Limits on max types are moot and we should let rails know that.'
+        assert_equal nil, @varcharmax10.limit, 'Limits on max types are moot and we should let rails know that.'
+      end
     end
 
   end
   
   
+  context 'For all national/unicode columns' do
+    
+    setup do
+      @nchar         = SqlServerUnicode.columns_hash['nchar']
+      @nvarchar      = SqlServerUnicode.columns_hash['nvarchar']
+      @ntext         = SqlServerUnicode.columns_hash['ntext']
+      @ntext10       = SqlServerUnicode.columns_hash['ntext_10']
+      @nchar10       = SqlServerUnicode.columns_hash['nchar_10']
+      @nvarchar100   = SqlServerUnicode.columns_hash['nvarchar_100']
+      @nvarcharmax   = SqlServerUnicode.columns_hash['nvarchar_max']
+      @nvarcharmax10 = SqlServerUnicode.columns_hash['nvarchar_max_10']
+    end
+    
+    should 'all respond true to #is_utf8?' do
+      SqlServerUnicode.columns_hash.except('id').values.each do |column|
+        assert column.is_utf8?, "This column #{column.inspect} should have been a unicode column."
+      end
+    end
+    
+    should 'have correct simplified types' do
+      assert_equal :string, @nchar.type
+      assert_equal :string, @nvarchar.type
+      assert_equal :text,   @ntext.type
+      assert_equal :text,   @ntext10.type
+      assert_equal :string, @nchar10.type
+      assert_equal :string, @nvarchar100.type
+      if sqlserver_2005?
+        assert_equal :string, @nvarcharmax.type
+        assert_equal :string, @nvarcharmax10.type
+      end
+    end
+    
+    should 'have correct #sql_type per schema definition' do
+      assert_equal 'nchar(1)',      @nchar.sql_type,       'Specifing a nchar type with no limit is 1 by SQL Server standards.'
+      assert_equal 'nvarchar(255)', @nvarchar.sql_type,    'Default nvarchar limit is 255.'
+      assert_equal 'ntext',         @ntext.sql_type,       'Nice and clean ntext, limit means nothing here.'
+      assert_equal 'ntext',         @ntext10.sql_type,     'Even a next with a limit of 10 specified will mean nothing.'
+      assert_equal 'nchar(10)',     @nchar10.sql_type,     'An nchar with a limit of 10 needs to have it show up here.'
+      assert_equal 'nvarchar(100)', @nvarchar100.sql_type, 'An nvarchar with a specified limit of 100 needs to show it.'
+      if sqlserver_2005?
+        assert_equal 'nvarchar(max)', @nvarcharmax.sql_type,   'A -1 limit should be converted to max (max) type.'
+        assert_equal 'nvarchar(max)', @nvarcharmax10.sql_type, 'A -1 limit should be converted to max (max) type.'
+      end
+    end
+    
+    should 'have correct #limit per schema definition' do
+      assert_equal 1,   @nchar.limit
+      assert_equal 255, @nvarchar.limit
+      assert_equal nil, @ntext.limit,       'An ntext column limit is moot, it is a fixed variable length'
+      assert_equal 10,  @nchar10.limit
+      assert_equal 100, @nvarchar100.limit
+      if sqlserver_2005?
+        assert_equal nil, @nvarcharmax.limit,   'Limits on max types are moot and we should let rails know that.'
+        assert_equal nil, @nvarcharmax10.limit, 'Limits on max types are moot and we should let rails know that.'
+      end
+    end
+    
+  end
+  
+  context 'For datetime columns' do
+
+    setup do
+      @date = SqlServerChronic.columns_hash['date']
+      @time = SqlServerChronic.columns_hash['time']
+      @datetime = SqlServerChronic.columns_hash['datetime']
+    end
+
+    should 'have correct simplified type for uncast datetime' do
+      assert_equal :datetime, @datetime.type
+    end
+    
+    should 'all be a datetime #sql_type' do
+      assert_equal 'datetime', @date.sql_type
+      assert_equal 'datetime', @time.sql_type
+      assert_equal 'datetime', @datetime.sql_type
+    end
+    
+    should 'all be have nil #limit' do
+      assert_equal nil, @date.limit
+      assert_equal nil, @time.limit
+      assert_equal nil, @datetime.limit
+    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
+        assert_equal :date, @date.type, "This column: \n#{@date.inspect}"
+        assert_instance_of Date, @chronic_date.date
+      end
+      
+      should 'have column objects cast to time' do
+        assert_equal :time, @time.type, "This column: \n#{@time.inspect}"
+        assert_instance_of Time, @chronic_time.time
+      end
+      
+    end
+
+  end
+  
+  context 'For decimal and numeric columns' do
+    
+    setup do
+      @bank_balance = NumericData.columns_hash['bank_balance']
+      @big_bank_balance = NumericData.columns_hash['big_bank_balance']
+      @world_population = NumericData.columns_hash['world_population']
+      @my_house_population = NumericData.columns_hash['my_house_population']
+    end
+    
+    should 'have correct simplified types' do
+      assert_equal :decimal, @bank_balance.type
+      assert_equal :decimal, @big_bank_balance.type
+      assert_equal :integer, @world_population.type, 'Since #extract_scale == 0'
+      assert_equal :integer, @my_house_population.type, 'Since #extract_scale == 0'
+    end
+    
+    should 'have correct #sql_type' do
+      assert_equal 'decimal(10,2)', @bank_balance.sql_type
+      assert_equal 'decimal(15,2)', @big_bank_balance.sql_type
+      assert_equal 'decimal(10,0)', @world_population.sql_type
+      assert_equal 'decimal(2,0)',  @my_house_population.sql_type
+    end
+    
+    should 'have correct #limit' do
+      assert_equal nil, @bank_balance.limit
+      assert_equal nil, @big_bank_balance.limit
+      assert_equal nil, @world_population.limit
+      assert_equal nil, @my_house_population.limit
+    end
+    
+    should 'return correct precisions and scales' do
+      assert_equal [10,2], [@bank_balance.precision, @bank_balance.scale]
+      assert_equal [15,2], [@big_bank_balance.precision, @big_bank_balance.scale]
+      assert_equal [10,0], [@world_population.precision, @world_population.scale]
+      assert_equal [2,0],  [@my_house_population.precision, @my_house_population.scale]
+    end
+    
+  end
+  
   
 end

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -2,34 +2,47 @@ require 'cases/sqlserver_helper'
 
 class SchemaDumperTestSqlserver < ActiveRecord::TestCase
   
-  context 'In schema dump' do
-    
-    should 'include limit constraint for integer columns' do
-      output = standard_dump(/^(?!integer_limits)/)
-      assert_match %r{c_int_1.*:limit => 2}, output
-      assert_match %r{c_int_2.*:limit => 2}, output
-      assert_match %r{c_int_3.*}, output
-      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
+  setup :find_all_tables
+  
+  context 'For primary keys' do
+
+    should 'honor nonstandards' do
+      table_dump('movies') do |output|
+        match = output.match(%r{create_table "movies"(.*)do})
+        assert_not_nil(match, "nonstandardpk table not found")
+        assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
+      end
     end
     
-    should 'honor nonstandard primary keys' do
-      output = standard_dump
-      match = output.match(%r{create_table "movies"(.*)do})
-      assert_not_nil(match, "nonstandardpk table not found")
-      assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
+  end
+  
+  context 'For integers' do
+    
+    should 'include limit constraint that match logic for smallint and bigint in #extract_limit' do
+      table_dump('integer_limits') do |output|
+        assert_match %r{c_int_1.*:limit => 2}, output
+        assert_match %r{c_int_2.*:limit => 2}, output
+        assert_match %r{c_int_3.*}, output
+        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
     end
     
   end
   
   
+  
   private
   
+  def find_all_tables
+    @all_tables ||= ActiveRecord::Base.connection.tables
+  end
+  
   def standard_dump(ignore_tables = [])
     stream = StringIO.new
     ActiveRecord::SchemaDumper.ignore_tables = [*ignore_tables]
@@ -37,4 +50,12 @@ class SchemaDumperTestSqlserver < ActiveRecord::TestCase
     stream.string
   end
   
+  def table_dump(*table_names)
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = @all_tables-table_names
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    yield stream.string
+    stream.string
+  end
+  
 end

data/test/cases/sqlserver_helper.rb

@@ -19,6 +19,8 @@ class TableWithRealColumn < ActiveRecord::Base; end
 class FkTestHasFk < ActiveRecord::Base ; end
 class FkTestHasPk < ActiveRecord::Base ; end
 class NumericData < ActiveRecord::Base ; self.table_name = 'numeric_data' ; end
+class SqlServerUnicode < ActiveRecord::Base ; end
+class SqlServerString < ActiveRecord::Base ; end
 class SqlServerChronic < ActiveRecord::Base
   coerce_sqlserver_date :date
   coerce_sqlserver_time :time
@@ -72,6 +74,10 @@ end
 
 module ActiveRecord 
   class TestCase < ActiveSupport::TestCase
+    class << self
+      def sqlserver_2000? ; ActiveRecord::Base.connection.sqlserver_2000? ; end
+      def sqlserver_2005? ; ActiveRecord::Base.connection.sqlserver_2005? ; end
+    end
     def assert_sql(*patterns_to_match)
       $queries_executed = []
       yield
@@ -82,6 +88,8 @@ module ActiveRecord
       end
       assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found in:\n#{$queries_executed.inspect}"
     end
+    def sqlserver_2000? ; self.class.sqlserver_2000? ; end
+    def sqlserver_2005? ; self.class.sqlserver_2005? ; end
   end
 end
 

data/test/cases/table_name_test_sqlserver.rb

@@ -0,0 +1,23 @@
+require 'cases/sqlserver_helper'
+require 'models/order'
+
+class TableNameTestSqlserver < ActiveRecord::TestCase
+  
+  self.use_transactional_fixtures = false
+  
+  def setup
+    Order.table_name = '[orders]'
+    Order.reset_column_information
+  end
+  
+  should 'load columns with escaped table name for model' do
+    assert_equal 4, Order.columns.length
+    
+  end
+  
+  should 'not re-escape table name if it is escaped already for SQL queries' do
+    assert_sql(/SELECT \* FROM \[orders\]/) { Order.all }
+  end
+  
+  
+end

data/test/cases/unicode_test_sqlserver.rb

@@ -0,0 +1,44 @@
+require 'cases/sqlserver_helper'
+
+class UnicodeTestSqlserver < ActiveRecord::TestCase
+  
+  
+  context 'Testing basic saves and unicode limits' do
+
+    should 'save and reload simple nchar string' do
+      assert nchar_data = SqlServerUnicode.create!(:nchar => 'A')
+      assert_equal 'A', SqlServerUnicode.find(nchar_data.id).nchar
+    end
+    
+    should 'save and reload simple nvarchar(max) string' do
+      test_string = 'Ken Collins'
+      assert nvarcharmax_data = SqlServerUnicode.create!(:nvarchar_max => test_string)
+      assert_equal test_string, SqlServerUnicode.find(nvarcharmax_data.id).nvarchar_max
+    end if sqlserver_2005?
+
+    should 'enforce default nchar_10 limit of 10' do
+      assert_raise(ActiveRecord::StatementInvalid) { SqlServerUnicode.create!(:nchar => '01234567891') }
+    end
+
+    should 'enforce default nvarchar_100 limit of 100' do
+      assert_raise(ActiveRecord::StatementInvalid) { SqlServerUnicode.create!(:nvarchar_100 => '0123456789'*10+'1') }
+    end
+
+  end
+  
+  context 'Testing unicode data' do
+
+    setup do
+      @unicode_data = "一二34五六"
+    end
+
+    should 'insert into nvarchar field' do
+      assert data = SqlServerUnicode.create!(:nvarchar => @unicode_data)
+      assert_equal @unicode_data, data.reload.nvarchar
+    end
+
+  end
+  
+  
+  
+end

data/test/schema/sqlserver_specific_schema.rb

@@ -2,6 +2,7 @@ ActiveRecord::Schema.define do
   
   create_table :table_with_real_columns, :force => true do |t|
     t.column :real_number, :real
+    # t.column :varchar_max, :varchar_max if ActiveRecord::Base.connection.sqlserver_2005?
   end
   
   create_table :defaults, :force => true do |t|
@@ -34,5 +35,30 @@ ActiveRecord::Schema.define do
     REFERENCES #{quote_table_name('fk_test_has_pks')} (#{quote_column_name('id')})
   ADDFKSQL
   
+  create_table :sql_server_unicodes, :force => true do |t|
+    t.column :nchar,          :nchar
+    t.column :nvarchar,       :nvarchar
+    t.column :ntext,          :ntext
+    t.column :ntext_10,       :ntext,     :limit => 10
+    t.column :nchar_10,       :nchar,     :limit => 10
+    t.column :nvarchar_100,   :nvarchar,  :limit => 100
+    if ActiveRecord::Base.connection.sqlserver_2005?
+      t.column :nvarchar_max,     :nvarchar_max 
+      t.column :nvarchar_max_10,  :nvarchar_max, :limit => 10
+    end
+  end
+  
+  create_table :sql_server_strings, :force => true do |t|
+    t.column :char,     :char
+    t.column :char_10,  :char,  :limit => 10
+    if ActiveRecord::Base.connection.sqlserver_2005?
+      t.column :varchar_max,     :varchar_max 
+      t.column :varchar_max_10,  :varchar_max, :limit => 10
+    end
+  end
+  
+  create_table :sql_server_binary_types, :force => true do |t|
+    # TODO: Add some different native binary types and test.
+  end
   
 end

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification 
 name: rails-sqlserver-2000-2005-adapter
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 2.2.0
 platform: ruby
 authors: 
 - Ken Collins
 - Murray Steele
 - Shawn Balestracci
+- Joe Rafaniello
 - Tom Ward
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-11-19 00:00:00 -08:00
+date: 2008-11-21 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -82,6 +83,8 @@ test_files:
 - 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