activerecord-sqlserver-adapter 2.3.10 → 2.3.11

data/CHANGELOG

@@ -1,4 +1,9 @@
 
+* 2.3.11
+
+* Add TinyTds/dblib connection mode. [Ken Collins]
+
+
 * 2.3.10
 
 * Fix DSN'less code. [Erik Bryn]

data/Rakefile

@@ -22,7 +22,7 @@ task :test => ['test:odbc']
 
 namespace :test do
   
-  ['odbc','adonet'].each do |mode|
+  ['dblib','odbc','adonet'].each do |mode|
     
     Rake::TestTask.new(mode) do |t|
       t.libs = test_libs(mode)
@@ -44,7 +44,7 @@ end
 
 namespace :profile do
   
-  ['odbc','adonet'].each do |mode|
+  ['dblib','odbc','adonet'].each do |mode|
     namespace mode.to_sym do
       
       Dir.glob("test/profile/*_profile_case.rb").sort.each do |test_file|

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -12,6 +12,9 @@ module ActiveRecord
       config.reverse_merge! :mode => :odbc, :host => 'localhost', :username => 'sa', :password => ''
       mode = config[:mode].to_s.downcase.underscore.to_sym
       case mode
+      when :dblib
+        raise ArgumentError, 'Missing :dataserver configuration.' unless config.has_key?(:dataserver)
+        require_library_or_gem 'tiny_tds'
       when :odbc
         require_library_or_gem 'odbc' unless defined?(ODBC)
         require 'active_record/connection_adapters/sqlserver_adapter/core_ext/odbc'
@@ -173,16 +176,18 @@ module ActiveRecord
     class SQLServerAdapter < AbstractAdapter
       
       ADAPTER_NAME                = 'SQLServer'.freeze
-      VERSION                     = '2.3.10'.freeze
+      VERSION                     = '2.3.11'.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'].to_set.freeze
       QUOTED_TRUE, QUOTED_FALSE   = '1', '0'
       LOST_CONNECTION_EXCEPTIONS  = {
+        :dblib  => ['TinyTds::Error'],
         :odbc   => ['ODBC::Error'],
         :adonet => ['TypeError','System::Data::SqlClient::SqlException']
       }
       LOST_CONNECTION_MESSAGES    = {
+        :dblib  => [/closed connection/],
         :odbc   => [/link failure/, /server failed/, /connection was already closed/, /invalid handle/i],
         :adonet => [/current state is closed/, /network-related/]
       }
@@ -348,6 +353,15 @@ module ActiveRecord
       # CONNECTION MANAGEMENT ====================================#
       
       def active?
+        connected = case @connection_options[:mode]
+                    when :dblib
+                      !@connection.closed?
+                    when :odbc
+                      true
+                    else :adonet
+                      true
+                    end
+        return false if !connected
         raw_connection_do("SELECT 1")
         true
       rescue *lost_connection_exceptions
@@ -362,6 +376,8 @@ module ActiveRecord
 
       def disconnect!
         case @connection_options[:mode]
+        when :dblib
+          @connection.close rescue nil
         when :odbc
           @connection.disconnect rescue nil
         else :adonet
@@ -414,8 +430,8 @@ module ActiveRecord
       end
       
       def execute(sql, name = nil, skip_logging = false)
-        if table_name = query_requires_identity_insert?(sql)
-          with_identity_insert_enabled(table_name) { do_execute(sql,name) }
+        if id_insert_table_name = query_requires_identity_insert?(sql)
+          with_identity_insert_enabled(id_insert_table_name) { do_execute(sql,name) }
         else
           do_execute(sql,name)
         end
@@ -424,19 +440,27 @@ module ActiveRecord
       def execute_procedure(proc_name, *variables)
         vars = variables.map{ |v| quote(v) }.join(', ')
         sql = "EXEC #{proc_name} #{vars}".strip
+        name = 'Execute Procedure'
         results = []
-        log(sql,'Execute Procedure') do
-          raw_connection_run(sql) do |handle|
-            get_rows = lambda {
-              rows = handle_to_names_and_values handle, :fetch => :all
-              rows.each_with_index { |r,i| rows[i] = r.with_indifferent_access }
-              results << rows
-            }
-            get_rows.call
-            while handle_more_results?(handle)
+        case @connection_options[:mode]
+        when :dblib
+          results << select(sql, name).map { |r| r.with_indifferent_access }
+        when :odbc
+          log(sql, name) do
+            raw_connection_run(sql) do |handle|
+              get_rows = lambda {
+                rows = handle_to_names_and_values handle, :fetch => :all
+                rows.each_with_index { |r,i| rows[i] = r.with_indifferent_access }
+                results << rows
+              }
               get_rows.call
+              while handle_more_results?(handle)
+                get_rows.call
+              end
             end
           end
+        when :adonet
+          results << select(sql, name).map { |r| r.with_indifferent_access }
         end
         results.many? ? results : results.first
       end
@@ -813,6 +837,23 @@ module ActiveRecord
       def connect
         config = @connection_options
         @connection = case @connection_options[:mode]
+                      when :dblib
+                        appname = config[:appname] || Rails.application.class.name.split('::').first rescue nil
+                        encoding = config[:encoding].present? ? config[:encoding] : nil
+                        TinyTds::Client.new({ 
+                          :dataserver    => config[:dataserver],
+                          :username      => config[:username],
+                          :password      => config[:password],
+                          :database      => config[:database],
+                          :appname       => appname,
+                          :login_timeout => config[:dblib_login_timeout],
+                          :timeout       => config[:dblib_timeout],
+                          :encoding      => encoding
+                        }).tap do |client|
+                          client.execute("SET ANSI_DEFAULTS ON").do
+                          client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
+                          client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
+                        end
                       when :odbc
                         if config[:dsn].include?(';')
                           driver = ODBC::Driver.new.tap do |d|
@@ -889,6 +930,8 @@ module ActiveRecord
       def raw_connection_run(sql)
         with_auto_reconnect do
           case @connection_options[:mode]
+          when :dblib
+            @connection.execute(sql)
           when :odbc
             block_given? ? @connection.run_block(sql) { |handle| yield(handle) } : @connection.run(sql)
           else :adonet
@@ -899,15 +942,21 @@ module ActiveRecord
       
       def raw_connection_do(sql)
         case @connection_options[:mode]
+        when :dblib
+          @insert_sql ? @connection.execute(sql).insert : @connection.execute(sql).do
         when :odbc
           @connection.do(sql)
         else :adonet
           @connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_non_query
         end
+      ensure
+        @insert_sql = false
+        @update_sql = false
       end
       
       def finish_statement_handle(handle)
         case @connection_options[:mode]
+        when :dblib
         when :odbc
           handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
         when :adonet
@@ -924,12 +973,24 @@ module ActiveRecord
       end
       
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        super || select_value("SELECT SCOPE_IDENTITY() AS Ident")
+        @insert_sql = true
+        case @connection_options[:mode]
+        when :dblib
+          execute(sql, name) || id_value
+        else
+          super || select_value("SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident")
+        end
       end
       
       def update_sql(sql, name = nil)
-        execute(sql, name)
-        select_value('SELECT @@ROWCOUNT AS AffectedRows')
+        @update_sql = true
+        case @connection_options[:mode]
+        when :dblib
+          execute(sql, name)
+        else
+          execute(sql, name)
+          select_value('SELECT @@ROWCOUNT AS AffectedRows')
+        end
       end
       
       def info_schema_query
@@ -955,6 +1016,7 @@ module ActiveRecord
       
       def handle_more_results?(handle)
         case @connection_options[:mode]
+        when :dblib
         when :odbc
           handle.more_results
         when :adonet
@@ -964,12 +1026,23 @@ module ActiveRecord
       
       def handle_to_names_and_values(handle, options={})
         case @connection_options[:mode]
+        when :dblib
+          handle_to_names_and_values_dblib(handle, options)
         when :odbc
           handle_to_names_and_values_odbc(handle, options)
         when :adonet
           handle_to_names_and_values_adonet(handle, options)
         end
       end
+      
+      def handle_to_names_and_values_dblib(handle, options={})
+        query_options = {}.tap do |qo|
+          qo[:timezone] = ActiveRecord::Base.default_timezone || :utc
+          qo[:first] = true if options[:fetch] == :one
+          qo[:as] = options[:fetch] == :rows ? :array : :hash
+        end
+        handle.each(query_options)
+      end
 
       def handle_to_names_and_values_odbc(handle, options={})
         @connection.use_utc = ActiveRecord::Base.default_timezone == :utc if @connection_supports_native_types

data/test/cases/connection_test_sqlserver.rb

@@ -12,24 +12,6 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
   end
   
   
-  should 'return finished ODBC statment handle from #execute without block' do
-    assert_all_statements_used_are_closed do
-      @connection.execute('SELECT * FROM [topics]')
-    end
-  end
-  
-  should 'finish ODBC statment handle from #execute with block' do
-    assert_all_statements_used_are_closed do
-      @connection.execute('SELECT * FROM [topics]') { }
-    end
-  end
-  
-  should 'finish connection from #raw_select' do
-    assert_all_statements_used_are_closed do
-      @connection.send(:raw_select,'SELECT * FROM [topics]')
-    end
-  end
-  
   should 'affect rows' do
     topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
     updated = Topic.update(topic_data.keys, topic_data.values)
@@ -39,38 +21,6 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
     assert_equal 2, Topic.delete([1, 2])        
   end
   
-  should 'execute without block closes statement' do
-    assert_all_statements_used_are_closed do
-      @connection.execute("SELECT 1")
-    end
-  end
-  
-  should 'execute with block closes statement' do
-    assert_all_statements_used_are_closed do
-      @connection.execute("SELECT 1") do |sth|
-        assert !sth.finished?, "Statement should still be alive within block"
-      end
-    end
-  end
-  
-  should 'insert with identity closes statement' do
-    assert_all_statements_used_are_closed do
-      @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)")
-    end
-  end
-  
-  should 'insert without identity closes statement' do
-    assert_all_statements_used_are_closed do
-      @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)")
-    end
-  end
-
-  should 'active closes statement' do
-    assert_all_statements_used_are_closed do
-      @connection.active?
-    end
-  end
-  
   should 'allow usage of :database connection option to remove setting from dsn' do
     assert_equal 'activerecord_unittest', @connection.current_database
     begin
@@ -82,6 +32,61 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
     end
   end
   
+  context 'ODBC connection management' do
+
+    should 'return finished ODBC statement handle from #execute without block' do
+      assert_all_odbc_statements_used_are_closed do
+        @connection.execute('SELECT * FROM [topics]')
+      end
+    end
+
+    should 'finish ODBC statement handle from #execute with block' do
+      assert_all_odbc_statements_used_are_closed do
+        @connection.execute('SELECT * FROM [topics]') { }
+      end
+    end
+
+    should 'finish connection from #raw_select' do
+      assert_all_odbc_statements_used_are_closed do
+        @connection.send(:raw_select,'SELECT * FROM [topics]')
+      end
+    end
+
+    should 'execute without block closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        @connection.execute("SELECT 1")
+      end
+    end
+
+    should 'execute with block closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        @connection.execute("SELECT 1") do |sth|
+          assert !sth.finished?, "Statement should still be alive within block"
+        end
+      end
+    end
+
+    should 'insert with identity closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)")
+      end
+    end
+
+    should 'insert without identity closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)")
+      end
+    end
+
+    should 'active closes statement' do
+      assert_all_odbc_statements_used_are_closed do
+        @connection.active?
+      end
+    end
+
+  end if connection_mode_odbc?
+  
+  
   context 'Connection management' do
     
     setup do
@@ -116,21 +121,18 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
   
   private
   
-  def assert_all_statements_used_are_closed(&block)
+  def assert_all_odbc_statements_used_are_closed(&block)
+    odbc = @connection.raw_connection.class.parent
     existing_handles = []
-    ObjectSpace.each_object(ODBC::Statement) {|handle| existing_handles << handle}
-    GC.disable
+    ObjectSpace.each_object(odbc::Statement) { |h| existing_handles << h }
+    existing_handle_ids = existing_handles.map(&:object_id)
+    assert existing_handles.all?(&:finished?), "Somewhere before the block some statements were not closed"
+    GC.disable    
     yield
     used_handles = []
-    ObjectSpace.each_object(ODBC::Statement) {|handle| used_handles << handle unless existing_handles.include? handle}
-    assert_block "No statements were used within given block" do
-      used_handles.size > 0
-    end
-    ObjectSpace.each_object(ODBC::Statement) do |handle|
-      assert_block "Statement should have been closed within given block" do
-        handle.finished?
-      end
-    end
+    ObjectSpace.each_object(odbc::Statement) { |h| used_handles << h unless existing_handle_ids.include?(h.object_id) }
+    assert used_handles.size > 0, "No statements were used within given block"
+    assert used_handles.all?(&:finished?), "Statement should have been closed within given block"
   ensure
     GC.enable
   end

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -20,15 +20,23 @@ class ExecuteProcedureTestSqlserver < ActiveRecord::TestCase
     assert_equal 'TABLE', table_info[:TABLE_TYPE], "Table Info: #{table_info.inspect}"
   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']
+  if connection_mode_odbc?
+    
+    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
+    
+  else
+    
+    should 'allow multiple result sets to be returned'
+    
   end
   
   

data/test/cases/sqlserver_helper.rb

@@ -104,6 +104,7 @@ end
 module ActiveRecord 
   class TestCase < ActiveSupport::TestCase
     class << self
+      def connection_mode_dblib? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :dblib ; end
       def connection_mode_odbc? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :odbc ; end
       def sqlserver_2000? ; ActiveRecord::Base.connection.sqlserver_2000? ; end
       def sqlserver_2005? ; ActiveRecord::Base.connection.sqlserver_2005? ; end
@@ -122,6 +123,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 connection_mode_dblib? ; self.class.connection_mode_dblib? ; end
+    def connection_mode_odbc? ; self.class.connection_mode_odbc? ; end
     def sqlserver_2000? ; self.class.sqlserver_2000? ; end
     def sqlserver_2005? ; self.class.sqlserver_2005? ; end
     def sqlserver_2008? ; self.class.sqlserver_2008? ; end

data/test/connections/native_sqlserver/connection.rb

@@ -2,7 +2,8 @@ print "Using SQLServer via ADONET\n"
 require_dependency 'models/course'
 require 'logger'
 
-ActiveRecord::Base.logger = Logger.new("debug.log")
+ActiveRecord::Base.logger = Logger.new(File.expand_path(File.join(SQLSERVER_TEST_ROOT,'debug.log')))
+ActiveRecord::Base.logger.level = 0
 
 ActiveRecord::Base.configurations = {
   'arunit' => {

data/test/connections/native_sqlserver_odbc/connection.rb

@@ -2,7 +2,8 @@ print "Using SQLServer via ODBC\n"
 require_dependency 'models/course'
 require 'logger'
 
-ActiveRecord::Base.logger = Logger.new("debug.log")
+ActiveRecord::Base.logger = Logger.new(File.expand_path(File.join(SQLSERVER_TEST_ROOT,'debug.log')))
+ActiveRecord::Base.logger.level = 0
 
 ActiveRecord::Base.configurations = {
   'arunit' => {

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 2
   - 3
-  - 10
-  version: 2.3.10
+  - 11
+  version: 2.3.11
 platform: ruby
 authors: 
 - Ken Collins
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-21 00:00:00 -04:00
+date: 2010-10-17 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency