Add TinyTDS/dblib connection mode.

Author: metaskills

Gemfile

@@ -3,6 +3,7 @@ source :rubygems
 
 gemspec :path => ENV['RAILS_SOURCE']
 gem 'arel', :path => ENV['AREL'] if ENV['AREL']
+gem 'tiny_tds', :path => ENV['TINYTDS_SOURCE'] if ENV['TINYTDS_SOURCE']
 
 
 group :development do

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|

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -71,19 +71,27 @@ def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
         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
@@ -179,7 +187,7 @@ def select(sql, name = nil)
         end
 
         def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-          super || select_value("SELECT SCOPE_IDENTITY() AS Ident")
+          super || select_value("SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident")
         end
 
         def update_sql(sql, name = nil)
@@ -204,6 +212,8 @@ def do_execute(sql, name = nil)
 
         def raw_connection_do(sql)
           case @connection_options[:mode]
+          when :dblib
+            @connection.execute(sql).do
           when :odbc
             @connection.do(sql)
           else :adonet
@@ -227,6 +237,8 @@ def raw_select(sql, name=nil, options={})
         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
@@ -237,6 +249,7 @@ def raw_connection_run(sql)
 
         def handle_more_results?(handle)
           case @connection_options[:mode]
+          when :dblib
           when :odbc
             handle.more_results
           when :adonet
@@ -246,13 +259,24 @@ def handle_more_results?(handle)
 
         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
           case options[:fetch]
@@ -351,6 +375,7 @@ def handle_to_names_and_values_adonet(handle, options={})
 
         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

lib/active_record/connection_adapters/sqlserver/errors.rb

@@ -8,11 +8,13 @@ module Sqlserver
       module Errors
 
         LOST_CONNECTION_EXCEPTIONS  = {
+          :dblib  => ['TinyTds::Error'],
           :odbc   => ['ODBC::Error','ODBC_UTF8::Error','ODBC_NONE::Error'],
           :adonet => ['TypeError','System::Data::SqlClient::SqlException']
         }.freeze
 
         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/]
         }.freeze

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -20,6 +20,9 @@ def self.sqlserver_connection(config) #:nodoc:
       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
         raise ArgumentError, 'Missing :dsn configuration.' unless config.has_key?(:dsn)
         if RUBY_VERSION < '1.9'
@@ -242,6 +245,15 @@ def disable_referential_integrity
       # === Abstract Adapter (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
@@ -256,6 +268,8 @@ def reconnect!
 
       def disconnect!
         case @connection_options[:mode]
+        when :dblib
+          @connection.close rescue nil
         when :odbc
           @connection.disconnect rescue nil
         else :adonet
@@ -351,6 +365,23 @@ def translate_exception(e, message)
       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
                         odbc = ['::ODBC','::ODBC_UTF8','::ODBC_NONE'].detect{ |odbc_ns| odbc_ns.constantize rescue nil }.constantize
                         if config[:dsn].include?(';')

test/cases/execute_procedure_test_sqlserver.rb

@@ -20,15 +20,23 @@ def setup
     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
 
 

test/cases/sqlserver_helper.rb

@@ -93,6 +93,7 @@ def raw_select_with_query_record(sql, name=nil, options={})
 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_2005? ; ActiveRecord::Base.connection.sqlserver_2005? ; end
       def sqlserver_2008? ; ActiveRecord::Base.connection.sqlserver_2008? ; end
@@ -109,6 +110,7 @@ def assert_sql(*patterns_to_match)
       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_2005? ; self.class.sqlserver_2005? ; end
     def sqlserver_2008? ; self.class.sqlserver_2008? ; end

test/connections/native_sqlserver_dblib/connection.rb

@@ -0,0 +1,30 @@
+print "Using SQLServer via DBLIB\n"
+require_dependency 'models/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(File.expand_path(File.join(SQLSERVER_TEST_ROOT,'debug.log')))
+ActiveRecord::Base.logger.level = 0
+
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter    => 'sqlserver',
+    :mode       => 'dblib',
+    :dataserver => ENV['TINYTDS_UNIT_DATASERVER'],
+    :username   => 'rails',
+    :password   => '',
+    :database   => 'activerecord_unittest',
+    :appname    => 'SQLServerUnit'
+  },
+  'arunit2' => {
+    :adapter    => 'sqlserver',
+    :mode       => 'dblib',
+    :dataserver => ENV['TINYTDS_UNIT_DATASERVER'],
+    :username   => 'rails',
+    :password   => '',
+    :database   => 'activerecord_unittest2',
+    :appname    => 'SQLServerUnit2'
+  }
+}
+
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

test/profile/connection_profile_case.rb

@@ -20,7 +20,7 @@ def test_select
   def test_select_one
     select_statement = "SELECT [topics].* FROM [topics]"
     ruby_profile :connection_select_one do
-      3000.times { @connection.select_one(select_statement) }
+      1000.times { @connection.select_one(select_statement) }
     end
   end