activerecord-sqlserver-adapter 2.3.4 → 2.3.5

data/CHANGELOG

@@ -2,6 +2,29 @@
 MASTER
 
 
+* 2.3.5
+
+* Initial IronRuby ADONET connection mode support baked right in. Removed most &block 
+  parameters, no handle/request object yielded anymore. Better abstraction and compliance 
+  per the ActiveRecord abstract adapter to not yielding handles for #execute and only for 
+  low level #select. Better wrapping of all queries at lowest level in #log so exceptions 
+  at anytime can be handled correctly by core AR. Critical for System::Data's command 
+  readers. Better abstraction for introspecting on #connection_mode. Added support for 
+  running singular test cases via TextMate's Command-R. [Ken Collins]
+  
+* Force a binary encoding on values coming in and out of those columns for ruby 1.9.
+  Fixes ticket #33 [Jeroen Zwartepoorte]
+
+* Using change_column will leave default if the type does not change or a new default
+  is not included. Fixes issue #22. [Ransom Briggs]
+
+* Use correct SP name for sp_MSforeachtable so any collation can get to it. [7to3]
+
+* Qualify INFORMATION_SCHEMA.COLUMNS with a correct period DB name if present.
+
+* Allow adapter to return multipe results sets, for example from stored procedures. [Chris Hall]
+
+
 * 2.3.4
 
 * For tables that named with schema(ex. rails.users), they could not get length of column.

data/README.rdoc

@@ -6,7 +6,8 @@ The SQL Server adapter for rails is back for ActiveRecord 2.2 and up! We are cur
 
 == What's New
 
-* Strict ODBC required! No DBI means around 20% faster!
+* IronRuby support using ADONET connection mode.
+* Direct ODBC mode. No DBI anymore, means around 20% faster!
 * Now supports SQL Server 2008 too!
 * Fully tested under 1.9!!! Correctly encodes/decodes UTF-8 types in ruby 1.9 too.
 * Now supports both rails 2.2 & 2.3!!!
@@ -129,7 +130,7 @@ It is our goal to match the adapter version with each version of rails. However
 
 == Installation
 
-You will need Ruby ODBC. If you are using the adapter under 1.9, then you need at least ruby-odbc version 0.9996. Currently ADO modes are not supported since we dropped the unnecessary DBI dependency and transport layer. This was done so we could incorporate other transports such as ADO.NET (w IronRuby) mode in the future or possibly a straight FreeTDS layer. The sky is the limit now and we have a code that can be accept these optional transports. If you are interested in helping, open a ticket and submit a patch. Or start a conversation on the Google Group.
+You will need Ruby ODBC. If you are using the adapter under 1.9, then you need at least ruby-odbc version 0.9996. ODBC is the preferred mode, however if you are using IronRuby you can use the ADONET connection mode which uses native System.Data connection. Other connection modes may be supported, possibly a straight FreeTDS layer. The sky is the limit now and we have a code that can be accept these optional transports. If you are interested in helping, open a ticket and submit a patch. Or start a conversation on the Google Group.
 
   $ gem install activerecord-sqlserver-adapter
 
@@ -142,6 +143,19 @@ Here are some external links for libraries and/or tutorials on how to install an
 * http://www.ch-werner.de/rubyodbc/
 
 
+== IronRuby ADONET Mode
+
+A few details on this implementation. All that is needed in your database.yml configuration file is "mode: adonet" vs "odbc" and if you are running IronRuby, the connection will be native. You can also specify an "integrated_security: true" option in your configuration, remember to remove the username/password options too. To use this adapter, you will not need need ANY DBI middle layer or special extension gems to the adapter. 
+
+This adapter is opinionated in regards to IronRuby on types going in and out of the DB. For example strings will be String, not System::String and DateTime vs System::Datetime. There are many more examples but the rule of thumb is that the types will be simple types that correlate to a standard Ruby implementation. We enforce this basic rule because it is necessary to pass the tests and let the framework do its job. We recommend sticking to native Ruby types in your application code too.
+
+The adapter establishes a System::Data::SqlClient connection that has both MultipleActiveResultSets (MARS) and Pooling turned off. There are good reasons for this one because the connection would not work otherwise for all the code issued by ActiveRecord. Remember too that ActiveRecord has it's own connection pooling and these underlying features like MARS/Pooling work against the adapter code.
+
+Currently IronRuby is passing most of the ActiveRecord and Adapter tests. Here is a list of the ones remaining. Some are in the adapter's realm and some are in Marshaling area of IronRuby's core to fix. Feel like helping knock these out? Submit a patch to github issues.
+
+http://gist.github.com/381101
+
+
 == Contributing
 
 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 on github issues. 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.

data/RUNNING_UNIT_TESTS

@@ -34,9 +34,10 @@ test databases. Use an empty password for said user.
 
 == Running with Rake
 
-The easiest way to run the unit tests is through Rake. Either run "rake test_sqlserver" 
-or "rake test_sqlserver_odbc". For more information, checkout the full array 
-of rake tasks with "rake -T"
+The easiest way to run the unit tests is through Rake. Either run "rake test" which 
+defaults to ODBC mode or being mode specific using either "rake sqlserver:test:adonet" 
+or "rake sqlserver:test:odbc". For more information, checkout the full array of rake tasks 
+with "rake -T"
 
 Rake can be found at http://rake.rubyforge.org
 

data/Rakefile

@@ -4,38 +4,38 @@ require 'rake/rdoctask'
 
 
 namespace :sqlserver do
-
-  ['sqlserver','sqlserver_odbc'].each do |adapter|
-
-    Rake::TestTask.new("test_#{adapter}") do |t|
-      t.libs << "test" 
-      t.libs << "test/connections/native_#{adapter}"
-      t.libs << "../../../rails/activerecord/test/"
-      t.test_files = (
-        Dir.glob("test/cases/**/*_test_sqlserver.rb").sort + 
-        Dir.glob("../../../rails/activerecord/test/**/*_test.rb").sort )
-      t.verbose = true
+  
+  namespace :test do
+    
+    ['odbc','adonet'].each do |mode|
+
+      Rake::TestTask.new(mode) do |t|
+        t.libs << "test"
+        t.libs << "test/connections/native_sqlserver#{mode == 'adonet' ? '' : "_#{mode}"}"
+        t.libs << "../../../rails/activerecord/test/"
+        t.test_files = (
+          Dir.glob("test/cases/**/*_test_sqlserver.rb").sort + 
+          Dir.glob("../../../rails/activerecord/test/**/*_test.rb").sort )
+        t.verbose = true
+      end
+      
     end
 
-    namespace adapter do
-      task :test => "test_#{adapter}"
+    desc 'Test with unicode types enabled, uses ODBC mode.'
+    task :unicode_types do
+      ENV['ENABLE_DEFAULT_UNICODE_TYPES'] = 'true'
+      test = Rake::Task['sqlserver:test:odbc']
+      test.invoke
     end
-
-  end
-
-  desc 'Test with unicode types enabled.'
-  task :test_unicode_types do
-    ENV['ENABLE_DEFAULT_UNICODE_TYPES'] = 'true'
-    test = Rake::Task['sqlserver:test_sqlserver_odbc']
-    test.invoke
+    
   end
   
 end
 
 
-desc 'Test the default ODBC mode, taks sqlserver:test_sqlserver_odbc.'
+desc 'Default runs tests for the adapters ODBC mode.'
 task :test do
-  test = Rake::Task['sqlserver:test_sqlserver_odbc']
+  test = Rake::Task['sqlserver:test:odbc']
   test.invoke
 end
 

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -16,7 +16,9 @@ module ActiveRecord
         require_library_or_gem 'odbc' unless defined?(ODBC)
         require 'active_record/connection_adapters/sqlserver_adapter/core_ext/odbc'
         raise ArgumentError, 'Missing :dsn configuration.' unless config.has_key?(:dsn)
-        config = config.slice :dsn, :username, :password
+      when :adonet
+        require 'System.Data'
+        raise ArgumentError, 'Missing :database configuration.' unless config.has_key?(:database)
       when :ado
         raise NotImplementedError, 'Please use version 2.3.1 of the adapter for ADO connections. Future versions may support ADO.NET.'
         raise ArgumentError, 'Missing :database configuration.' unless config.has_key?(:database)
@@ -54,10 +56,12 @@ module ActiveRecord
         end
         
         def string_to_binary(value)
+          value = value.dup.force_encoding(Encoding::BINARY) if value.respond_to?(:force_encoding)
          "0x#{value.unpack("H*")[0]}"
         end
         
         def binary_to_string(value)
+          value = value.dup.force_encoding(Encoding::BINARY) if value.respond_to?(:force_encoding)
           value =~ /[^[:xdigit:]]/ ? value : [value].pack('H*')
         end
         
@@ -159,17 +163,17 @@ module ActiveRecord
     class SQLServerAdapter < AbstractAdapter
       
       ADAPTER_NAME                = 'SQLServer'.freeze
-      VERSION                     = '2.3.4'.freeze
+      VERSION                     = '2.3.5'.freeze
       DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+(\d{4})/
       SUPPORTED_VERSIONS          = [2000,2005,2008].freeze
       LIMITABLE_TYPES             = ['string','integer','float','char','nchar','varchar','nvarchar'].freeze
       LOST_CONNECTION_EXCEPTIONS  = {
-        :odbc => ['ODBC::Error'],
-        :ado  => []
+        :odbc   => ['ODBC::Error'],
+        :adonet => ['TypeError','System::Data::SqlClient::SqlException']
       }
       LOST_CONNECTION_MESSAGES    = {
-        :odbc => [/link failure/, /server failed/, /connection was already closed/, /invalid handle/i],
-        :ado  => []
+        :odbc   => [/link failure/, /server failed/, /connection was already closed/, /invalid handle/i],
+        :adonet => [/current state is closed/, /network-related/]
       }
       
       cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
@@ -316,11 +320,11 @@ module ActiveRecord
       
       # REFERENTIAL INTEGRITY ====================================#
       
-      def disable_referential_integrity(&block)
-        do_execute "EXEC sp_MSForEachTable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'"
+      def disable_referential_integrity
+        do_execute "EXEC sp_MSforeachtable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'"
         yield
       ensure
-        do_execute "EXEC sp_MSForEachTable 'ALTER TABLE ? CHECK CONSTRAINT ALL'"
+        do_execute "EXEC sp_MSforeachtable 'ALTER TABLE ? CHECK CONSTRAINT ALL'"
       end
       
       # CONNECTION MANAGEMENT ====================================#
@@ -339,34 +343,14 @@ module ActiveRecord
       end
 
       def disconnect!
-        raw_connection.disconnect rescue nil
-      end
-      
-      def raw_connection_run(sql)
-        with_auto_reconnect do
-          case connection_mode
-          when :odbc
-            block_given? ? raw_connection.run_block(sql) { |handle| yield(handle) } : raw_connection.run(sql)
-          else :ado
-
-          end
-        end
-      end
-      
-      def raw_connection_do(sql)
         case connection_mode
         when :odbc
-          raw_connection.do(sql)
-        else :ado
-          
+          raw_connection.disconnect rescue nil
+        else :adonet
+          raw_connection.close rescue nil
         end
       end
       
-      def finish_statement_handle(handle)
-        handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
-        handle
-      end
-      
       # DATABASE STATEMENTS ======================================#
       
       def user_options
@@ -394,23 +378,26 @@ module ActiveRecord
       end
       
       def select_rows(sql, name = nil)
-        raw_select(sql,name).last
+        raw_select(sql,name).first.last
       end
       
-      def execute(sql, name = nil, &block)
+      def execute(sql, name = nil, skip_logging = false)
         if table_name = query_requires_identity_insert?(sql)
-          handle = with_identity_insert_enabled(table_name) { raw_execute(sql,name,&block) }
+          with_identity_insert_enabled(table_name) { do_execute(sql,name) }
         else
-          handle = raw_execute(sql,name,&block)
+          do_execute(sql,name)
         end
-        finish_statement_handle(handle)
       end
       
       def execute_procedure(proc_name, *variables)
         vars = variables.map{ |v| quote(v) }.join(', ')
         sql = "EXEC #{proc_name} #{vars}".strip
         select(sql,'Execute Procedure',true).inject([]) do |results,row|
-          results << row.with_indifferent_access
+          if row.kind_of?(Array)
+            results << row.inject([]) { |rs,r| rs << r.with_indifferent_access }
+          else
+            results << row.with_indifferent_access
+          end
         end
       end
       
@@ -649,10 +636,13 @@ module ActiveRecord
       
       def change_column(table_name, column_name, type, options = {})
         sql_commands = []
-        remove_default_constraint(table_name, column_name)
+        column_object = columns(table_name).detect { |c| c.name.to_s == column_name.to_s }
         change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
         change_column_sql << " NOT NULL" if options[:null] == false
         sql_commands << change_column_sql
+        if options_include_default?(options) || (column_object && column_object.type != type.to_sym)
+         	remove_default_constraint(table_name,column_name)
+        end
         if options_include_default?(options)
           remove_sqlserver_columns_cache_for(table_name)
           sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_name(table_name,column_name)} DEFAULT #{quote(options[:default])} FOR #{quote_column_name(column_name)}"
@@ -773,8 +763,19 @@ module ActiveRecord
         @connection = case connection_mode
                       when :odbc
                         ODBC.connect config[:dsn], config[:username], config[:password]
-                      when :ado
-                        
+                      when :adonet
+                        System::Data::SqlClient::SqlConnection.new.tap do |connection|
+                          connection.connection_string = System::Data::SqlClient::SqlConnectionStringBuilder.new.tap do |cs|
+                            cs.user_i_d = config[:username] if config[:username]
+                            cs.password = config[:password] if config[:password]
+                            cs.integrated_security = true if config[:integrated_security] == 'true'
+                            cs.add 'Server', config[:host].to_clr_string
+                            cs.initial_catalog = config[:database]
+                            cs.multiple_active_result_sets = false
+                            cs.pooling = false
+                          end.to_s
+                          connection.open
+                        end
                       end
       rescue
         raise unless @auto_connecting
@@ -820,11 +821,50 @@ module ActiveRecord
         @auto_connecting = false
       end
       
+      def raw_connection_run(sql)
+        with_auto_reconnect do
+          case connection_mode
+          when :odbc
+            block_given? ? raw_connection.run_block(sql) { |handle| yield(handle) } : raw_connection.run(sql)
+          else :adonet
+            raw_connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_reader
+          end
+        end
+      end
+      
+      def raw_connection_do(sql)
+        case connection_mode
+        when :odbc
+          raw_connection.do(sql)
+        else :adonet
+          raw_connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_non_query
+        end
+      end
+      
+      def finish_statement_handle(handle)
+        case connection_mode
+        when :odbc
+          handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
+        when :adonet
+          handle.close if handle && handle.respond_to?(:close) && !handle.is_closed
+          handle.dispose if handle && handle.respond_to?(:dispose)
+        end
+        handle
+      end
+      
       # DATABASE STATEMENTS ======================================
       
       def select(sql, name = nil, ignore_special_columns = false)
         repair_special_columns(sql) unless ignore_special_columns
-        fields, rows = raw_select(sql,name)
+        fields_and_row_sets = raw_select(sql,name)
+        final_result_set = fields_and_row_sets.inject([]) do |rs,fields_and_rows|
+          fields, rows = fields_and_rows
+          rs << zip_fields_and_rows(fields,rows)
+        end
+        final_result_set.many? ? final_result_set : final_result_set.first
+      end
+      
+      def zip_fields_and_rows(fields, rows)
         rows.inject([]) do |results,row|
           row_hash = {}
           fields.each_with_index do |f, i|
@@ -847,10 +887,6 @@ module ActiveRecord
         log_info_schema_queries ? yield : ActiveRecord::Base.silence{ yield }
       end
       
-      def raw_execute(sql, name = nil, &block)
-        log(sql,name) { raw_connection_run(sql) }
-      end
-      
       def do_execute(sql,name=nil)
         log(sql, name || 'EXECUTE') do
           with_auto_reconnect { raw_connection_do(sql) }
@@ -858,9 +894,41 @@ module ActiveRecord
       end
       
       def raw_select(sql, name = nil)
-        handle = raw_execute(sql,name)
-        fields = handle.columns(true).map{|c|c.name}
-        results = handle_as_array(handle)
+        fields_and_row_sets = []
+        log(sql,name) do
+          begin
+            handle = raw_connection_run(sql)
+            loop do
+              fields_and_rows = case connection_mode
+                                when :odbc
+                                  handle_to_fields_and_rows_odbc(handle)
+                                when :adonet
+                                  handle_to_fields_and_rows_adonet(handle)
+                                end
+              fields_and_row_sets << fields_and_rows
+              break unless handle_more_results?(handle)
+            end
+          ensure
+            finish_statement_handle(handle)
+          end
+        end
+        fields_and_row_sets
+      end
+      
+      def handle_more_results?(handle)
+        case connection_mode
+        when :odbc
+          handle.more_results
+        when :adonet
+          handle.next_result
+        end
+      end
+      
+      def handle_to_fields_and_rows_odbc(handle)
+        fields = handle.columns(true).map { |c| c.name }
+        results = handle.inject([]) do |rows,row|
+          rows << row.inject([]) { |values,value| values << value }
+        end
         rows = results.inject([]) do |rows,row|
           row.each_with_index do |value, i|
             if value.is_a? ODBC::TimeStamp
@@ -869,15 +937,37 @@ module ActiveRecord
           end
           rows << row
         end
-        return fields, rows
-      end
-      
-      def handle_as_array(handle)
-        array = handle.inject([]) do |rows,row|
-          rows << row.inject([]){ |values,value| values << value }
+        [fields,rows]
+      end
+      
+      def handle_to_fields_and_rows_adonet(handle)
+        if handle.has_rows
+          fields = []
+          rows = []
+          fields_named = false
+          while handle.read
+            row = []
+            handle.visible_field_count.times do |row_index|
+              value = handle.get_value(row_index)
+              value = if value.is_a? System::String
+                        value.to_s
+                      elsif value.is_a? System::DBNull
+                        nil
+                      elsif value.is_a? System::DateTime
+                        value.to_string("yyyy-MM-dd HH:MM:ss.fff").to_s
+                      else
+                        value
+                      end
+              row << value
+              fields << handle.get_name(row_index).to_s unless fields_named
+            end
+            rows << row
+            fields_named = true
+          end
+        else
+          fields, rows = [], []
         end
-        finish_statement_handle(handle)
-        array
+        [fields,rows]
       end
       
       def add_limit_offset_for_association_limiting!(sql, options)
@@ -924,7 +1014,7 @@ module ActiveRecord
       
       # IDENTITY INSERTS =========================================#
       
-      def with_identity_insert_enabled(table_name, &block)
+      def with_identity_insert_enabled(table_name)
         table_name = quote_table_name(table_name_or_views_table_name(table_name))
         set_identity_insert(table_name, true)
         yield
@@ -1031,6 +1121,7 @@ module ActiveRecord
       
       def column_definitions(table_name)
         db_name = unqualify_db_name(table_name)
+        db_name_with_period = "#{db_name}." if db_name
         table_name = unqualify_table_name(table_name)
         sql = %{
           SELECT
@@ -1052,7 +1143,7 @@ module ActiveRecord
             WHEN COLUMNPROPERTY(OBJECT_ID(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME), columns.COLUMN_NAME, 'IsIdentity') = 0 THEN NULL
             ELSE 1
           END as is_identity
-          FROM #{db_name}INFORMATION_SCHEMA.COLUMNS columns
+          FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS columns
           WHERE columns.TABLE_NAME = '#{table_name}'
           ORDER BY columns.ordinal_position
         }.gsub(/[ \t\r\n]+/,' ')
@@ -1072,7 +1163,7 @@ module ActiveRecord
           if ci[:default_value].nil? && views.include?(table_name)
             real_table_name = table_name_or_views_table_name(table_name)
             real_column_name = views_real_column_name(table_name,ci[:name])
-            col_default_sql = "SELECT c.COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = '#{real_table_name}' AND c.COLUMN_NAME = '#{real_column_name}'"
+            col_default_sql = "SELECT c.COLUMN_DEFAULT FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = '#{real_table_name}' AND c.COLUMN_NAME = '#{real_column_name}'"
             ci[:default_value] = info_schema_query { select_value(col_default_sql) }
           end
           ci[:default_value] = case ci[:default_value]

data/lib/active_record/connection_adapters/sqlserver_adapter/core_ext/odbc.rb

@@ -20,7 +20,6 @@ module ActiveRecord
               true
             end
           end
-          
         end
 
         module Database

data/test/cases/connection_test_sqlserver.rb

@@ -13,9 +13,9 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
   
   
   should 'return finished ODBC statment handle from #execute without block' do
-    handle = @connection.execute('SELECT * FROM [topics]')
-    assert_instance_of ODBC::Statement, handle
-    assert handle.finished?
+    assert_all_statements_used_are_closed do
+      @connection.execute('SELECT * FROM [topics]')
+    end
   end
   
   should 'finish ODBC statment handle from #execute with block' do
@@ -24,12 +24,6 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
     end
   end
   
-  should 'return an unfinished ODBC statement handler from #raw_execute' do
-    handle = @connection.send(:raw_execute,'SELECT * FROM [topics]')
-    assert_instance_of ODBC::Statement, handle
-    assert !handle.finished?
-  end
-  
   should 'finish connection from #raw_select' do
     assert_all_statements_used_are_closed do
       @connection.send(:raw_select,'SELECT * FROM [topics]')

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -29,5 +29,16 @@ class ExecuteProcedureTestSqlserver < ActiveRecord::TestCase
     end if sqlserver_2000?
   end
   
+  should 'allow multiple result sets to be returned' do
+    results1, results2 = @klass.execute_procedure('sp_helpconstraint','accounts')
+    assert_instance_of Array, results1
+    assert_instance_of HashWithIndifferentAccess, results1.first
+    assert results1.first['Object Name']
+    assert_instance_of Array, results2
+    assert_instance_of HashWithIndifferentAccess, results2.first
+    assert results2.first['constraint_name']
+    assert results2.first['constraint_type']
+  end
+  
   
 end

data/test/cases/migration_test_sqlserver.rb

@@ -46,9 +46,21 @@ class MigrationTestSqlserver < ActiveRecord::TestCase
       assert lock_version_column.default.nil?
     end
     
+    should 'not drop the default contraint if just renaming' do
+      find_default = lambda do 
+        @connection.select_all("EXEC sp_helpconstraint 'defaults','nomsg'").select do |row|     
+          row['constraint_type'] == "DEFAULT on column decimal_number"
+        end.last
+      end
+      default_before = find_default.call
+      @connection.change_column :defaults, :decimal_number, :decimal, :precision => 4
+      default_after = find_default.call
+      assert default_after
+      assert_equal default_before['constraint_keys'], default_after['constraint_keys']
+    end
+    
   end
   
-  
 end
 
 

data/test/cases/sqlserver_helper.rb

@@ -1,6 +1,10 @@
 require 'rubygems'
 require 'shoulda'
 require 'mocha'
+[ File.expand_path(File.join(File.dirname(__FILE__),'..','..','test')),
+  File.expand_path(File.join(File.dirname(__FILE__),'..','..','test','connections','native_sqlserver_odbc')),
+  File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','..','rails','activerecord','test'))
+].each{ |lib| $:.unshift(lib) unless $:.include?(lib) } if ENV['TM_DIRECTORY']
 require 'cases/helper'
 require 'models/topic'
 require 'active_record/version'

data/test/connections/native_sqlserver/connection.rb

@@ -1,4 +1,4 @@
-print "Using native SQLServer\n"
+print "Using SQLServer via ADONET\n"
 require_dependency 'models/course'
 require 'logger'
 
@@ -7,12 +7,14 @@ ActiveRecord::Base.logger = Logger.new("debug.log")
 ActiveRecord::Base.configurations = {
   'arunit' => {
     :adapter  => 'sqlserver',
+    :mode     => 'ADONET',
     :host     => 'localhost',
     :username => 'rails',
     :database => 'activerecord_unittest'
   },
   'arunit2' => {
     :adapter  => 'sqlserver',
+    :mode     => 'ADONET',
     :host     => 'localhost',
     :username => 'rails',
     :database => 'activerecord_unittest2'

data/test/connections/native_sqlserver_odbc/connection.rb

@@ -1,4 +1,4 @@
-print "Using native SQLServer via ODBC\n"
+print "Using SQLServer via ODBC\n"
 require_dependency 'models/course'
 require 'logger'
 

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
-  version: 2.3.4
+  prerelease: false
+  segments: 
+  - 2
+  - 3
+  - 5
+  version: 2.3.5
 platform: ruby
 authors: 
 - Ken Collins
@@ -54,18 +59,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: SQL Server 2000, 2005 and 2008 Adapter For Rails.