activerecord-jdbc-adapter 0.9.4-java → 0.9.5-java

data/History.txt

@@ -1,3 +1,14 @@
+== 0.9.5
+
+- The MSSQL release, courtesy of Mike Williams and Lonely
+  Planet.
+- JRuby + AR-JDBC is now seen as the hassle-free way of using Rails
+  with SQLServer!
+- Many fixes for MSSQL, including ACTIVERECORD_JDBC-18,
+  ACTIVERECORD_JDBC-41, ACTIVERECORD_JDBC-56, ACTIVERECORD_JDBC-94,
+  ACTIVERECORD_JDBC-99, JRUBY-3805, JRUBY-3793, JRUBY-4221
+- All tests pass on Rails 3.0.0.beta3!
+
 == 0.9.4
 
 - ACTIVERECORD_JDBC-96: DB2 JdbcSpec cannot dump schema correctly

data/Manifest.txt

@@ -14,6 +14,7 @@ lib/active_record/connection_adapters/informix_adapter.rb
 lib/active_record/connection_adapters/jdbc_adapter.rb
 lib/active_record/connection_adapters/jdbc_adapter_spec.rb
 lib/active_record/connection_adapters/jndi_adapter.rb
+lib/active_record/connection_adapters/mssql_adapter.rb
 lib/active_record/connection_adapters/mysql_adapter.rb
 lib/active_record/connection_adapters/oracle_adapter.rb
 lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -60,6 +61,11 @@ test/jndi_callbacks_test.rb
 test/jndi_test.rb
 test/manualTestDatabase.rb
 test/minirunit.rb
+test/mssql_db_create_test.rb
+test/mssql_identity_insert_test.rb
+test/mssql_legacy_types_test.rb
+test/mssql_limit_offset_test.rb
+test/mssql_multibyte_test.rb
 test/mssql_simple_test.rb
 test/mysql_db_create_test.rb
 test/mysql_info_test.rb

data/README.txt

@@ -16,7 +16,7 @@ What's there, and what is not there:
 * MySQL - Complete support
 * PostgreSQL - Complete support
 * Oracle - Complete support
-* Microsoft SQL Server - Complete support except for change_column_default
+* Microsoft SQL Server - Complete support
 * DB2 - Complete, except for the migrations:
   * change_column 
   * change_column_default
@@ -57,6 +57,7 @@ To use activerecord-jdbc-adapter with JRuby on Rails:
   * derby (<tt>activerecord-jdbcderby-adapter</tt>)
   * hsqldb (<tt>activerecord-jdbchsqldb-adapter</tt>)
   * h2 (<tt>activerecord-jdbch2-adapter</tt>)
+  * mssql (<tt>activerecord-jdbcmssql-adapter</tt>)
 
 2a. For Rails 3, if you're generating a new application, use the
     following command to generate your application:

data/lib/active_record/connection_adapters/mssql_adapter.rb

@@ -0,0 +1,13 @@
+tried_gem = false
+begin
+  require "jdbc/jtds"
+rescue LoadError
+  unless tried_gem
+    require 'rubygems'
+    gem "jdbc-mssql"
+    tried_gem = true
+    retry
+  end
+  # trust that the jtds jar is already present
+end
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/jdbc_adapter/jdbc.rake

@@ -63,7 +63,8 @@ namespace :db do
         ActiveRecord::Base.establish_connection(config.merge({'database' => nil, 'url' => url}))
         ActiveRecord::Base.connection.create_database(config['database'])
         ActiveRecord::Base.establish_connection(config)
-      rescue
+      rescue => e
+        raise e unless config['adapter'] =~ /mysql|postgresql|sqlite/
         previous_create_database(config.merge('adapter' => config['adapter'].sub(/^jdbc/, '')))
       end
     end

data/lib/jdbc_adapter/jdbc_mssql.rb

@@ -1,20 +1,35 @@
 require 'jdbc_adapter/tsql_helper'
 
 module ::JdbcSpec
+
+  module ActiveRecordExtensions
+
+    def mssql_connection(config)
+      require "active_record/connection_adapters/mssql_adapter"
+      config[:host] ||= "localhost"
+      config[:port] ||= 1433
+      config[:url] ||= "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      config[:driver] ||= "net.sourceforge.jtds.jdbc.Driver"
+      embedded_driver(config)
+    end
+
+  end
+
   module MsSQL
+    
     include TSqlMethods
 
     def self.extended(mod)
       unless @lob_callback_added
         ActiveRecord::Base.class_eval do
           def after_save_with_mssql_lob
-          self.class.columns.select { |c| c.sql_type =~ /image/i }.each do |c|
-            value = self[c.name]
-            value = value.to_yaml if unserializable_attribute?(c.name, c)
-            next if value.nil?  || (value == '')
+            self.class.columns.select { |c| c.sql_type =~ /image/i }.each do |c|
+              value = self[c.name]
+              value = value.to_yaml if unserializable_attribute?(c.name, c)
+              next if value.nil?  || (value == '')
 
-            connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
-          end
+              connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
+            end
           end
         end
 
@@ -35,30 +50,42 @@ module ::JdbcSpec
       ::ActiveRecord::ConnectionAdapters::MssqlJdbcConnection
     end
 
+    def modify_types(tp) #:nodoc:
+      super(tp)
+      tp[:string] = {:name => "NVARCHAR", :limit => 255}
+      tp[:text]   = {:name => "NVARCHAR(MAX)"}
+      tp
+    end
+      
     module Column
+      
       attr_accessor :identity, :is_special
 
       def simplified_type(field_type)
         case field_type
-          when /int|bigint|smallint|tinyint/i                        then :integer
-          when /numeric/i                                            then (@scale.nil? || @scale == 0) ? :integer : :decimal
-          when /float|double|decimal|money|real|smallmoney/i         then :decimal
-          when /datetime|smalldatetime/i                             then :datetime
-          when /timestamp/i                                          then :timestamp
-          when /time/i                                               then :time
-          when /date/i                                               then :date
-          when /text|ntext/i                                         then :text
-          when /binary|image|varbinary/i                             then :binary
-          when /char|nchar|nvarchar|string|varchar/i                 then :string
-          when /bit/i                                                then :boolean
-          when /uniqueidentifier/i                                   then :string
+        when /int|bigint|smallint|tinyint/i                        then :integer
+        when /numeric/i                                            then (@scale.nil? || @scale == 0) ? :integer : :decimal
+        when /float|double|decimal|money|real|smallmoney/i         then :decimal
+        when /datetime|smalldatetime/i                             then :datetime
+        when /timestamp/i                                          then :timestamp
+        when /time/i                                               then :time
+        when /date/i                                               then :date
+        when /text|ntext/i                                         then :text
+        when /binary|image|varbinary/i                             then :binary
+        when /char|nchar|nvarchar|string|varchar/i                 then :string
+        when /bit/i                                                then :boolean
+        when /uniqueidentifier/i                                   then :string
         end
       end
 
+      def default_value(value)
+        return $1 if value =~ /^\(N?'(.*)'\)$/
+        value
+      end
+      
       def type_cast(value)
         return nil if value.nil? || value == "(null)" || value == "(NULL)"
         case type
-        when :string then unquote_string value
         when :integer then unquote(value).to_i rescue value ? 1 : 0
         when :primary_key then value == true || value == false ? value == true ? 1 : 0 : value.to_i
         when :decimal   then self.class.value_to_decimal(unquote(value))
@@ -70,11 +97,11 @@ module ::JdbcSpec
         when :binary    then unquote value
         else value
         end
+        
       end
 
-      # JRUBY-2011: Match balanced quotes and parenthesis - 'text',('text') or (text)
-      def unquote_string(value)
-        value.to_s.sub(/^\((.*)\)$/,'\1').sub(/^'(.*)'$/,'\1')
+      def is_utf8?
+        sql_type =~ /nvarchar|ntext|nchar/i
       end
 
       def unquote(value)
@@ -112,6 +139,7 @@ module ::JdbcSpec
       def self.string_to_binary(value)
         ''
       end
+      
     end
 
     def quote(value, column = nil)
@@ -125,8 +153,10 @@ module ::JdbcSpec
         elsif column && [:integer, :float].include?(column.type)
           value = column.type == :integer ? value.to_i : value.to_f
           value.to_s
-        else
+        elsif !column.respond_to?(:is_utf8?) || column.is_utf8?
           "N'#{quote_string(value)}'" # ' (for ruby-mode)
+        else
+          super
         end
       when TrueClass             then '1'
       when FalseClass            then '0'
@@ -154,14 +184,34 @@ module ::JdbcSpec
       quote false
     end
 
+    def add_limit_offset!(sql, options)
+      limit = options[:limit]
+      if limit
+        offset = (options[:offset] || 0).to_i
+        start_row = offset + 1
+        end_row = offset + limit.to_i
+        order = (options[:order] || determine_order_clause(sql))
+        sql.sub!(/ ORDER BY.*$/i, '')
+        find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/i
+        whole, select, rest_of_query = find_select.match(sql).to_a
+        new_sql = "#{select} t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY #{order}) AS row_num, #{rest_of_query}"
+        new_sql << ") AS t WHERE t.row_num BETWEEN #{start_row.to_s} AND #{end_row.to_s}"
+        sql.replace(new_sql)
+      end
+    end
+
     def change_order_direction(order)
-      order.split(",").collect {|fragment|
+      order.split(",").collect do |fragment|
         case fragment
         when  /\bDESC\b/i     then fragment.gsub(/\bDESC\b/i, "ASC")
         when  /\bASC\b/i      then fragment.gsub(/\bASC\b/i, "DESC")
         else                  String.new(fragment).split(',').join(' DESC,') + ' DESC'
         end
-      }.join(",")
+      end.join(",")
+    end
+
+    def supports_ddl_transactions?
+      true
     end
 
     def recreate_database(name)
@@ -179,159 +229,191 @@ module ::JdbcSpec
       execute "USE #{name}"
     end
 
-      def rename_table(name, new_name)
-        execute "EXEC sp_rename '#{name}', '#{new_name}'"
-      end
+    def rename_table(name, new_name)
+      execute "EXEC sp_rename '#{name}', '#{new_name}'"
+    end
 
-      # Adds a new column to the named table.
-      # See TableDefinition#column for details of the options you can use.
-      def add_column(table_name, column_name, type, options = {})
-        add_column_sql = "ALTER TABLE #{table_name} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(add_column_sql, options)
-        # TODO: Add support to mimic date columns, using constraints to mark them as such in the database
-        # add_column_sql << " CONSTRAINT ck__#{table_name}__#{column_name}__date_only CHECK ( CONVERT(CHAR(12), #{quote_column_name(column_name)}, 14)='00:00:00:000' )" if type == :date
-        execute(add_column_sql)
-      end
+    # Adds a new column to the named table.
+    # See TableDefinition#column for details of the options you can use.
+    def add_column(table_name, column_name, type, options = {})
+      add_column_sql = "ALTER TABLE #{table_name} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      add_column_options!(add_column_sql, options)
+      # TODO: Add support to mimic date columns, using constraints to mark them as such in the database
+      # add_column_sql << " CONSTRAINT ck__#{table_name}__#{column_name}__date_only CHECK ( CONVERT(CHAR(12), #{quote_column_name(column_name)}, 14)='00:00:00:000' )" if type == :date
+      execute(add_column_sql)
+    end
 
-      def rename_column(table, column, new_column_name)
-        execute "EXEC sp_rename '#{table}.#{column}', '#{new_column_name}'"
-      end
+    def rename_column(table, column, new_column_name)
+      execute "EXEC sp_rename '#{table}.#{column}', '#{new_column_name}'"
+    end
 
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        sql_commands = ["ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"]
-        if options_include_default?(options)
-          remove_default_constraint(table_name, column_name)
-          sql_commands << "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(options[:default], options[:column])} FOR #{column_name}"
-        end
-        sql_commands.each {|c|
-          execute(c)
-        }
-      end
-      def change_column_default(table_name, column_name, default) #:nodoc:
-        remove_default_constraint(table_name, column_name)
-        execute "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(default, column_name)} FOR #{column_name}"
-      end
-      def remove_column(table_name, column_name)
-        remove_check_constraints(table_name, column_name)
-        remove_default_constraint(table_name, column_name)
-        execute "ALTER TABLE #{table_name} DROP COLUMN [#{column_name}]"
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      change_column_type(table_name, column_name, type, options)
+      change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
+    end
+    
+    def change_column_type(table_name, column_name, type, options = {}) #:nodoc:
+      sql = "ALTER TABLE #{table_name} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      if options.has_key?(:null)
+        sql += (options[:null] ? " NULL" : " NOT NULL")
       end
-
-      def remove_default_constraint(table_name, column_name)
-        defaults = select "select def.name from sysobjects def, syscolumns col, sysobjects tab where col.cdefault = def.id and col.name = '#{column_name}' and tab.name = '#{table_name}' and col.id = tab.id"
-        defaults.each {|constraint|
-          execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["name"]}"
-        }
+      execute(sql)
+    end
+    
+    def change_column_default(table_name, column_name, default) #:nodoc:
+      remove_default_constraint(table_name, column_name)
+      unless default.nil?
+        execute "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(default)} FOR #{quote_column_name(column_name)}"
       end
+    end
+    
+    def remove_column(table_name, column_name)
+      remove_check_constraints(table_name, column_name)
+      remove_default_constraint(table_name, column_name)
+      execute "ALTER TABLE #{table_name} DROP COLUMN [#{column_name}]"
+    end
 
-      def remove_check_constraints(table_name, column_name)
-        # TODO remove all constraints in single method
-        constraints = select "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{table_name}' and COLUMN_NAME = '#{column_name}'"
-        constraints.each do |constraint|
-          execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["CONSTRAINT_NAME"]}"
-        end
-      end
+    def remove_default_constraint(table_name, column_name)
+      defaults = select "select def.name from sysobjects def, syscolumns col, sysobjects tab where col.cdefault = def.id and col.name = '#{column_name}' and tab.name = '#{table_name}' and col.id = tab.id"
+      defaults.each {|constraint|
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["name"]}"
+      }
+    end
 
-      def remove_index(table_name, options = {})
-        execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
+    def remove_check_constraints(table_name, column_name)
+      # TODO remove all constraints in single method
+      constraints = select "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{table_name}' and COLUMN_NAME = '#{column_name}'"
+      constraints.each do |constraint|
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["CONSTRAINT_NAME"]}"
       end
+    end
 
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
+    end
 
-      def columns(table_name, name = nil)
-        return [] if table_name =~ /^information_schema\./i
-        cc = super
-        cc.each do |col|
-          col.identity = true if col.sql_type =~ /identity/i
-          col.is_special = true if col.sql_type =~ /text|ntext|image/i
-        end
-        cc
+    def columns(table_name, name = nil)
+      return [] if table_name =~ /^information_schema\./i
+      cc = super
+      cc.each do |col|
+        col.identity = true if col.sql_type =~ /identity/i
+        col.is_special = true if col.sql_type =~ /text|ntext|image/i
       end
+      cc
+    end
 
-      def _execute(sql, name = nil)
-        if sql.lstrip =~ /^insert/i
-          if query_requires_identity_insert?(sql)
-            table_name = get_table_name(sql)
-            with_identity_insert_enabled(table_name) do
-              id = @connection.execute_insert(sql)
-            end
-          else
-            @connection.execute_insert(sql)
+    def _execute(sql, name = nil)
+      if sql.lstrip =~ /^insert/i
+        if query_requires_identity_insert?(sql)
+          table_name = get_table_name(sql)
+          with_identity_insert_enabled(table_name) do
+            id = @connection.execute_insert(sql)
           end
-        elsif sql.lstrip =~ /^\(?\s*(select|show)/i
-          repair_special_columns(sql)
-          @connection.execute_query(sql)
         else
-          @connection.execute_update(sql)
+          @connection.execute_insert(sql)
         end
+      elsif sql.lstrip =~ /^(create|exec)/i
+        @connection.execute_update(sql)
+      elsif sql.lstrip =~ /^\(?\s*(select|show)/i
+        repair_special_columns(sql)
+        @connection.execute_query(sql)
+      else
+        @connection.execute_update(sql)
       end
+    end
 
-      #SELECT .. FOR UPDATE is not supported on Microsoft SQL Server
-      def add_lock!(sql, options)
-        sql
-      end
+    #SELECT .. FOR UPDATE is not supported on Microsoft SQL Server
+    def add_lock!(sql, options)
+      sql
+    end
 
-      private
-      # Turns IDENTITY_INSERT ON for table during execution of the block
-      # N.B. This sets the state of IDENTITY_INSERT to OFF after the
-      # block has been executed without regard to its previous state
+    private
 
-      def with_identity_insert_enabled(table_name, &block)
-        set_identity_insert(table_name, true)
-        yield
-      ensure
-        set_identity_insert(table_name, false)
-      end
+    # Turns IDENTITY_INSERT ON for table during execution of the block
+    # N.B. This sets the state of IDENTITY_INSERT to OFF after the
+    # block has been executed without regard to its previous state
+    def with_identity_insert_enabled(table_name, &block)
+      set_identity_insert(table_name, true)
+      yield
+    ensure
+      set_identity_insert(table_name, false)
+    end
 
-      def set_identity_insert(table_name, enable = true)
-        execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
-      rescue Exception => e
-        raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
+    def set_identity_insert(table_name, enable = true)
+      execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+    rescue Exception => e
+      raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
+    end
+
+    def get_table_name(sql)
+      if sql =~ /^\s*insert\s+into\s+([^\(\s,]+)\s*|^\s*update\s+([^\(\s,]+)\s*/i
+        $1
+      elsif sql =~ /from\s+([^\(\s,]+)\s*/i
+        $1
+      else
+        nil
       end
+    end
 
-      def get_table_name(sql)
-        if sql =~ /^\s*insert\s+into\s+([^\(\s,]+)\s*|^\s*update\s+([^\(\s,]+)\s*/i
-          $1
-        elsif sql =~ /from\s+([^\(\s,]+)\s*/i
-          $1
-        else
-          nil
-        end
+    def identity_column(table_name)
+      @table_columns = {} unless @table_columns
+      @table_columns[table_name] = columns(table_name) if @table_columns[table_name] == nil
+      @table_columns[table_name].each do |col|
+        return col.name if col.identity
       end
 
-      def identity_column(table_name)
-        @table_columns = {} unless @table_columns
-        @table_columns[table_name] = columns(table_name) if @table_columns[table_name] == nil
-        @table_columns[table_name].each do |col|
-          return col.name if col.identity
-        end
+      return nil
+    end
 
-        return nil
+    def query_requires_identity_insert?(sql)
+      table_name = get_table_name(sql)
+      id_column = identity_column(table_name)
+      if sql.strip =~ /insert into [^ ]+ ?\((.+?)\)/i
+        insert_columns = $1.split(/, */).map(&method(:unquote_column_name))
+        return table_name if insert_columns.include?(id_column)
       end
+    end
 
-      def query_requires_identity_insert?(sql)
-        table_name = get_table_name(sql)
-        id_column = identity_column(table_name)
-        sql =~ /\[#{id_column}\]/ ? table_name : nil
+    def unquote_column_name(name)
+      if name =~ /^\[.*\]$/
+        name[1..-2]
+      else
+        name
       end
+    end
 
-      def get_special_columns(table_name)
-        special = []
-        @table_columns ||= {}
-        @table_columns[table_name] ||= columns(table_name)
-        @table_columns[table_name].each do |col|
-          special << col.name if col.is_special
-        end
-        special
+    def get_special_columns(table_name)
+      special = []
+      @table_columns ||= {}
+      @table_columns[table_name] ||= columns(table_name)
+      @table_columns[table_name].each do |col|
+        special << col.name if col.is_special
       end
+      special
+    end
 
-      def repair_special_columns(sql)
-        special_cols = get_special_columns(get_table_name(sql))
-        for col in special_cols.to_a
-          sql.gsub!(Regexp.new(" #{col.to_s} = "), " #{col.to_s} LIKE ")
-          sql.gsub!(/ORDER BY #{col.to_s}/i, '')
-        end
-        sql
+    def repair_special_columns(sql)
+      special_cols = get_special_columns(get_table_name(sql))
+      for col in special_cols.to_a
+        sql.gsub!(Regexp.new(" #{col.to_s} = "), " #{col.to_s} LIKE ")
+        sql.gsub!(/ORDER BY #{col.to_s}/i, '')
       end
+      sql
+    end
+        
+    def determine_order_clause(sql)
+      return $1 if sql =~ /ORDER BY (.*)$/
+      sql =~ /FROM +(\w+?)\b/ || raise("can't determine table name")
+      table_name = $1 
+      "#{table_name}.#{determine_primary_key(table_name)}" 
+    end
+
+    def determine_primary_key(table_name)
+      primary_key = columns(table_name).detect { |column| column.primary || column.identity }
+      primary_key ? primary_key.name : "id"
     end
+    
   end
+  
+end
 

data/lib/jdbc_adapter/version.rb

@@ -1,5 +1,5 @@
 module JdbcAdapter
   module Version
-    VERSION = "0.9.4"
+    VERSION = "0.9.5"
   end
 end

data/rakelib/test.rake

@@ -9,26 +9,33 @@ else
   task :test => [:test_mysql]
 end
 
-FileList['drivers/*'].each do |d|
-  next unless File.directory?(d)
-  driver = File.basename(d)
-  Rake::TestTask.new("test_#{driver}") do |t|
-    files = FileList["test/#{driver}*test.rb"]
-    if driver == "derby"
+def declare_test_task_for(adapter, options = {})
+  driver = options[:driver] || adapter
+  Rake::TestTask.new("test_#{adapter}") do |t|
+    files = FileList["test/#{adapter}*test.rb"]
+    if adapter == "derby"
       files << 'test/activerecord/connection_adapters/type_conversion_test.rb'
     end
     t.test_files = files
     t.libs = []
     if defined?(JRUBY_VERSION)
       t.ruby_opts << "-rjdbc/#{driver}"
-      t.libs << "lib" << "#{d}/lib"
-      t.libs.push *FileList["adapters/#{driver}*/lib"]
+      t.libs << "lib" << "drivers/#{driver}/lib"
+      t.libs.push *FileList["adapters/#{adapter}*/lib"]
     end
     t.libs << "test"
     t.verbose = true
   end
 end
 
+declare_test_task_for :derby
+declare_test_task_for :h2
+declare_test_task_for :hsqldb
+declare_test_task_for :mssql, :driver => :jtds
+declare_test_task_for :mysql
+declare_test_task_for :postgres
+declare_test_task_for :sqlite3
+
 Rake::TestTask.new(:test_jdbc) do |t|
   t.test_files = FileList['test/generic_jdbc_connection_test.rb', 'test/jndi_callbacks_test.rb']
   t.libs << 'test' << 'drivers/mysql/lib'
@@ -43,7 +50,7 @@ task :test_postgresql => [:test_postgres]
 task :test_pgsql => [:test_postgres]
 
 # Ensure driver for these DBs is on your classpath
-%w(oracle db2 cachedb mssql informix).each do |d|
+%w(oracle db2 cachedb informix).each do |d|
   Rake::TestTask.new("test_#{d}") do |t|
     t.test_files = FileList["test/#{d}_simple_test.rb"]
     t.libs = []

data/test/db/mssql.rb

@@ -1,9 +1,9 @@
-config = { 
+MSSQL_CONFIG = {
   :username => 'blog',
   :password => '',
-  :adapter  => 'jdbc',
-  :url => "jdbc:jtds:sqlserver://localhost:1433/weblog_development",
-  :driver => 'net.sourceforge.jtds.jdbc.Driver'
+  :adapter  => 'mssql',
+  :database => 'weblog_development'
 }
+MSSQL_CONFIG[:host] = ENV['SQLHOST'] if ENV['SQLHOST']
 
-ActiveRecord::Base.establish_connection( config )
+ActiveRecord::Base.establish_connection(MSSQL_CONFIG)

data/test/mssql_db_create_test.rb

@@ -0,0 +1,24 @@
+require 'abstract_db_create'
+require 'db/mssql'
+
+class MysqlDbCreateTest < Test::Unit::TestCase
+  include AbstractDbCreate
+
+  def db_config
+    MSSQL_CONFIG
+  end
+
+  def test_rake_db_create
+    begin
+      Rake::Task["db:create"].invoke
+    rescue => e
+      if e.message =~ /CREATE DATABASE permission denied/
+        puts "\nwarning: db:create test skipped; add 'dbcreator' role to user '#{db_config[:username]}' to run"
+        return
+      end
+    end
+    ActiveRecord::Base.establish_connection(db_config.merge(:database => "master"))
+    databases = ActiveRecord::Base.connection.select_rows("SELECT NAME FROM sys.sysdatabases").flatten
+    assert databases.include?(@db_name)
+  end
+end

data/test/mssql_identity_insert_test.rb

@@ -0,0 +1,19 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLIdentityInsertTest < Test::Unit::TestCase
+
+  include MigrationSetup
+  
+  def test_enable_identity_insert_when_necessary
+    Entry.connection.execute("INSERT INTO entries([id], [title]) VALUES (333, 'Title')")
+    Entry.connection.execute("INSERT INTO entries([title], [id]) VALUES ('Title', 344)")
+    Entry.connection.execute("INSERT INTO entries(id, title) VALUES (666, 'Title')")
+    Entry.connection.execute("INSERT INTO entries(id, title) (SELECT id+123, title FROM entries)")
+  end
+
+  def test_dont_enable_identity_insert_when_unnecessary
+    Entry.connection.execute("INSERT INTO entries([title]) VALUES ('[id]')")
+  end
+
+end

data/test/mssql_legacy_types_test.rb

@@ -0,0 +1,58 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+ActiveRecord::Schema.verbose = false
+
+class CreateArticles < ActiveRecord::Migration
+
+  def self.up
+    execute <<-SQL
+      CREATE TABLE articles (
+        [id] int NOT NULL IDENTITY(1, 1) PRIMARY KEY, 
+        [title] VARCHAR(100), 
+        [author] VARCHAR(60) DEFAULT 'anonymous', 
+        [body] TEXT
+      )
+    SQL
+  end
+
+  def self.down
+    drop_table "articles"
+  end
+
+end
+
+class Article < ActiveRecord::Base
+end
+
+class MsSQLLegacyTypesTest < Test::Unit::TestCase
+
+  def setup
+    CreateArticles.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    CreateArticles.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  def test_varchar_column
+    Article.create!(:title => "Blah blah")
+    article = Article.first
+    assert_equal("Blah blah", article.title)
+  end
+  
+  SAMPLE_TEXT = "Lorem ipsum dolor sit amet ..."
+  
+  def test_text_column
+    Article.create!(:body => SAMPLE_TEXT)
+    article = Article.first
+    assert_equal(SAMPLE_TEXT, article.body)
+  end
+  
+  def test_varchar_default_value
+    assert_equal("anonymous", Article.new.author)
+  end
+  
+end

data/test/mssql_limit_offset_test.rb

@@ -0,0 +1,108 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+ActiveRecord::Schema.verbose = false
+
+class CreateLongShips < ActiveRecord::Migration
+
+  def self.up
+    create_table "long_ships", :force => true do |t|
+      t.string "name", :limit => 50, :null => false
+      t.integer "width", :default => 123
+      t.integer "length", :default => 456
+    end
+  end
+
+  def self.down
+    drop_table "long_ships"
+  end
+
+end
+
+class LongShip < ActiveRecord::Base
+  has_many :vikings
+end
+
+class CreateVikings < ActiveRecord::Migration
+
+  def self.up
+    create_table "vikings", :force => true do |t|
+      t.integer "long_ship_id", :null => false
+      t.string "name", :limit => 50, :default => "Sven"
+    end
+  end
+
+  def self.down
+    drop_table "vikings"
+  end
+
+end
+
+class Viking < ActiveRecord::Base
+  belongs_to :long_ship
+end
+
+class MsSQLLimitOffsetTest < Test::Unit::TestCase
+
+  def setup
+    CreateLongShips.up
+    CreateVikings.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    CreateVikings.down
+    CreateLongShips.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  def test_limit_and_offset
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :offset => 2, :limit => 3).map(&:name)
+    assert_equal(%w(three four five), ship_names)
+  end
+
+  def test_limit_and_offset_with_order
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :order => "name", :offset => 4, :limit => 2).map(&:name)
+    assert_equal(%w(seven six), ship_names)
+  end
+
+  # TODO: work out how to fix DISTINCT support without breaking :include
+  # def test_limit_and_offset_with_distinct
+  #   %w(c a b a b a c d c d).each do |name|
+  #     LongShip.create!(:name => name)
+  #   end
+  #   ship_names = LongShip.find(:all, :select => "DISTINCT name", :order => "name", :offset => 1, :limit => 2).map(&:name)
+  #   assert_equal(%w(b c), ship_names)
+  # end
+
+  def test_limit_and_offset_with_include
+    skei = LongShip.create!(:name => "Skei")
+    skei.vikings.create!(:name => "Bob")
+    skei.vikings.create!(:name => "Ben")
+    skei.vikings.create!(:name => "Basil")
+    ships = Viking.find(:all, :include => :long_ship, :offset => 1, :limit => 2)
+    assert_equal(2, ships.size)
+  end
+
+  def test_limit_and_offset_with_include_and_order
+
+    boat1 = LongShip.create!(:name => "1-Skei")
+    boat2 = LongShip.create!(:name => "2-Skei")
+
+    boat1.vikings.create!(:name => "Adam")
+    boat2.vikings.create!(:name => "Ben")
+    boat1.vikings.create!(:name => "Carl")
+    boat2.vikings.create!(:name => "Donald")
+  
+    vikings = Viking.find(:all, :include => :long_ship, :order => "long_ships.name, vikings.name", :offset => 0, :limit => 3)
+    assert_equal(["Adam", "Carl", "Ben"], vikings.map(&:name))
+
+  end
+  
+end

data/test/mssql_multibyte_test.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLMultibyteTest < Test::Unit::TestCase
+  
+  include MultibyteTestMethods
+
+  def test_select_multibyte_string
+    Entry.create!(:title => 'テスト', :content => '本文')
+    entry = Entry.find(:last)
+    assert_equal "テスト", entry.title
+    assert_equal "本文", entry.content
+    assert_equal entry, Entry.find_by_title("テスト")
+  end
+    
+end

data/test/mssql_simple_test.rb

@@ -2,5 +2,48 @@ require 'jdbc_common'
 require 'db/mssql'
 
 class MsSQLSimpleTest < Test::Unit::TestCase
+
   include SimpleTestMethods
+
+  # MS SQL 2005 doesn't have a DATE class, only TIMESTAMP.
+  undef_method :test_save_date
+
+  # String comparisons are insensitive by default
+  undef_method :test_validates_uniqueness_of_strings_case_sensitive
+
+  def test_does_not_munge_quoted_strings
+    example_quoted_values = [%{'quoted'}, %{D'oh!}]
+    example_quoted_values.each do |value|
+      entry = Entry.create!(:title => value)
+      entry.reload
+      assert_equal(value, entry.title)
+    end
+  end
+
+  def test_change_column_default
+
+    Entry.connection.change_column "entries", "title", :string, :default => "new default"
+    Entry.reset_column_information
+    assert_equal("new default", Entry.new.title)
+
+    Entry.connection.change_column "entries", "title", :string, :default => nil
+    Entry.reset_column_information
+    assert_equal(nil, Entry.new.title)
+
+  end
+
+  def test_change_column_nullability
+    
+    Entry.connection.change_column "entries", "title", :string, :null => true
+    Entry.reset_column_information
+    title_column = Entry.columns.find { |c| c.name == "title" }
+    assert(title_column.null)
+
+    Entry.connection.change_column "entries", "title", :string, :null => false
+    Entry.reset_column_information
+    title_column = Entry.columns.find { |c| c.name == "title" }
+    assert(!title_column.null)
+
+  end
+
 end

data/test/simple.rb

@@ -305,8 +305,8 @@ module SimpleTestMethods
   end
 
   def test_validates_uniqueness_of_strings_case_sensitive
-    # MySQL string cmps are case-insensitive by default, so skip this test
-    return if ActiveRecord::Base.connection.config[:adapter] =~ /mysql/
+    # In MySQL and MsSQL, string cmps are case-insensitive by default, so skip this test
+    return if ActiveRecord::Base.connection.config[:adapter] =~ /m[sy]sql/
 
     name_lower = ValidatesUniquenessOfString.new(:cs_string => "name", :ci_string => '1')
     name_lower.save!

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 9
-    - 4
-  version: 0.9.4
+    - 5
+  version: 0.9.5
 platform: java
 authors: 
   - Nick Sieger, Ola Bini and JRuby contributors
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-05 00:00:00 -05:00
+date: 2010-04-22 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -49,6 +49,7 @@ files:
   - lib/active_record/connection_adapters/jdbc_adapter.rb
   - lib/active_record/connection_adapters/jdbc_adapter_spec.rb
   - lib/active_record/connection_adapters/jndi_adapter.rb
+  - lib/active_record/connection_adapters/mssql_adapter.rb
   - lib/active_record/connection_adapters/mysql_adapter.rb
   - lib/active_record/connection_adapters/oracle_adapter.rb
   - lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -95,6 +96,11 @@ files:
   - test/jndi_test.rb
   - test/manualTestDatabase.rb
   - test/minirunit.rb
+  - test/mssql_db_create_test.rb
+  - test/mssql_identity_insert_test.rb
+  - test/mssql_legacy_types_test.rb
+  - test/mssql_limit_offset_test.rb
+  - test/mssql_multibyte_test.rb
   - test/mssql_simple_test.rb
   - test/mysql_db_create_test.rb
   - test/mysql_info_test.rb