activerecord-sqlserver-adapter 4.1.8 → 4.2.0.pre

data/Rakefile

@@ -0,0 +1,48 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require_relative 'test/support/paths_sqlserver'
+require_relative 'test/support/rake_helpers'
+
+task test: ['test:dblib']
+task default: [:test]
+
+namespace :test do
+
+  %w(dblib odbc).each do |mode|
+
+    Rake::TestTask.new(mode) do |t|
+      t.libs = ARTest::SQLServer.test_load_paths
+      t.test_files = test_files
+      t.warning = !!ENV['WARNING']
+      t.verbose = true
+    end
+
+  end
+
+  task 'dblib:env' do
+    ENV['ARCONN'] = 'dblib'
+  end
+
+  task 'odbc:env' do
+    ENV['ARCONN'] = 'odbc'
+  end
+
+end
+
+task 'test:dblib' => 'test:dblib:env'
+task 'test:odbc' => 'test:odbc:env'
+
+namespace :profile do
+  ['dblib', 'odbc'].each do |mode|
+    namespace mode.to_sym do
+      Dir.glob('test/profile/*_profile_case.rb').sort.each do |test_file|
+        profile_case = File.basename(test_file).sub('_profile_case.rb', '')
+        Rake::TestTask.new(profile_case) do |t|
+          t.libs = ARTest::SQLServer.test_load_paths
+          t.test_files = [test_file]
+          t.verbose = true
+        end
+      end
+    end
+  end
+end

data/activerecord-sqlserver-adapter.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_record/connection_adapters/sqlserver/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = 'activerecord-sqlserver-adapter'
+  spec.version       = ActiveRecord::ConnectionAdapters::SQLServer::Version::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.authors       = ['Ken Collins', 'Anna Carey', 'Will Bond', 'Murray Steele', 'Shawn Balestracci', 'Joe Rafaniello', 'Tom Ward']
+  spec.email         = ['ken@metaskills.net', 'will@wbond.net']
+  spec.homepage      = 'http://github.com/rails-sqlserver/activerecord-sqlserver-adapter'
+  spec.summary       = 'ActiveRecord SQL Server Adapter.'
+  spec.description   = spec.summary
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.add_dependency 'activerecord', '~> 4.2.0'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'guard-minitest'
+  spec.add_development_dependency 'minitest', '< 5.3.4' # PENDING: [Rails5.x] Remove test order constraint.
+  spec.add_development_dependency 'minitest-focus'
+  spec.add_development_dependency 'minitest-spec-rails'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'nokogiri'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+end

data/lib/active_record/connection_adapters/sqlserver/core_ext/active_record.rb

@@ -1,17 +1,13 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       module CoreExt
         module ActiveRecord
-          extend ActiveSupport::Concern
 
-          included do
-            class_attribute :coerced_sqlserver_date_columns, :coerced_sqlserver_time_columns
-            self.coerced_sqlserver_date_columns = Set.new
-            self.coerced_sqlserver_time_columns = Set.new
-          end
+          extend ActiveSupport::Concern
 
           module ClassMethods
+
             def execute_procedure(proc_name, *variables)
               if connection.respond_to?(:execute_procedure)
                 connection.execute_procedure(proc_name, *variables)
@@ -20,18 +16,12 @@ module ActiveRecord
               end
             end
 
-            def coerce_sqlserver_date(*attributes)
-              self.coerced_sqlserver_date_columns += attributes.map(&:to_s)
-            end
-
-            def coerce_sqlserver_time(*attributes)
-              self.coerced_sqlserver_time_columns += attributes.map(&:to_s)
-            end
           end
+
         end
       end
     end
   end
 end
 
-ActiveRecord::Base.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ActiveRecord
+ActiveRecord::Base.send :include, ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::ActiveRecord

data/lib/active_record/connection_adapters/sqlserver/core_ext/attribute_methods.rb

@@ -0,0 +1,25 @@
+require 'active_record/attribute_methods'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module AttributeMethods
+
+
+          private
+
+          def attributes_for_update(attribute_names)
+            super.reject do |name|
+              column = self.class.columns_hash[name]
+              column && column.respond_to?(:is_identity?) && column.is_identity?
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::AttributeMethods

data/lib/active_record/connection_adapters/sqlserver/core_ext/explain.rb

@@ -1,8 +1,9 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       module CoreExt
         module Explain
+
           SQLSERVER_STATEMENT_PREFIX = 'EXEC sp_executesql '
           SQLSERVER_PARAM_MATCHER = /@\d+ =/
 
@@ -15,7 +16,7 @@ module ActiveRecord
 
           # This is somewhat hacky, but it should reliably reformat our prepared sql statment
           # which uses sp_executesql to just the first argument, then unquote it. Likewise our
-          # do_exec_query method should substitude the @n args withe the quoted values.
+          # `sp_executesql` method should substitude the @n args withe the quoted values.
           def unprepare_sqlserver_statement(sql)
             if sql.starts_with?(SQLSERVER_STATEMENT_PREFIX)
               executesql = sql.from(SQLSERVER_STATEMENT_PREFIX.length)
@@ -28,11 +29,12 @@ module ActiveRecord
               sql
             end
           end
+
         end
       end
     end
   end
 end
 
-ActiveRecord::Base.extend ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::Explain
-ActiveRecord::Relation.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::Explain
+ActiveRecord::Base.extend ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::Explain
+ActiveRecord::Relation.send :include, ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::Explain

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

@@ -1,28 +1,34 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       module CoreExt
         module ODBC
+
           module Statement
+
             def finished?
               connected?
               false
             rescue ::ODBC::Error
               true
             end
+
           end
 
           module Database
+
             def run_block(*args)
               yield sth = run(*args)
               sth.drop
             end
+
           end
+
         end
       end
     end
   end
 end
 
-ODBC::Statement.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ODBC::Statement
-ODBC::Database.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ODBC::Database
+ODBC::Statement.send :include, ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::ODBC::Statement
+ODBC::Database.send :include, ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::ODBC::Database

data/lib/active_record/connection_adapters/sqlserver/database_limits.rb

@@ -1,7 +1,8 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       module DatabaseLimits
+
         def table_alias_length
           128
         end
@@ -41,6 +42,7 @@ module ActiveRecord
         def joins_per_query
           256
         end
+
       end
     end
   end

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -1,9 +1,10 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       module DatabaseStatements
+
         def select_rows(sql, name = nil, binds = [])
-          do_exec_query sql, name, binds, fetch: :rows
+          sp_executesql sql, name, binds, fetch: :rows
         end
 
         def execute(sql, name = nil)
@@ -15,19 +16,17 @@ module ActiveRecord
         end
 
         def exec_query(sql, name = 'SQL', binds = [], sqlserver_options = {})
-          if id_insert_table_name = sqlserver_options[:insert] ? query_requires_identity_insert?(sql) : nil
-            with_identity_insert_enabled(id_insert_table_name) { do_exec_query(sql, name, binds) }
-          elsif update_sql?(sql)
-            sql = strip_ident_from_update(sql)
-            do_exec_query(sql, name, binds)
-          else
-            do_exec_query(sql, name, binds)
-          end
+          sp_executesql(sql, name, binds)
         end
 
-        # The abstract adapter ignores the last two parameters also
         def exec_insert(sql, name, binds, _pk = nil, _sequence_name = nil)
-          exec_query sql, name, binds, insert: true
+          id_insert = binds_have_identity_column?(binds)
+          id_table  = table_name_from_binds(binds) if id_insert
+          if id_insert && id_table
+            with_identity_insert_enabled(id_table) { exec_query(sql, name, binds) }
+          else
+            exec_query(sql, name, binds)
+          end
         end
 
         def exec_delete(sql, name, binds)
@@ -48,35 +47,44 @@ module ActiveRecord
           do_execute 'BEGIN TRANSACTION'
         end
 
-        def commit_db_transaction
-          disable_auto_reconnect { do_execute 'COMMIT TRANSACTION' }
+        def transaction_isolation_levels
+          super.merge snapshot: "SNAPSHOT"
         end
 
-        def rollback_db_transaction
-          do_execute 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION'
+        def begin_isolated_db_transaction(isolation)
+          set_transaction_isolation_level transaction_isolation_levels.fetch(isolation)
+          begin_db_transaction
         end
 
-        def create_savepoint(name = current_savepoint_name)
-          disable_auto_reconnect { do_execute "SAVE TRANSACTION #{name}" }
+        def set_transaction_isolation_level(isolation_level)
+          do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}"
+          begin_db_transaction
         end
 
-        def release_savepoint(name = current_savepoint_name)
+        def commit_db_transaction
+          do_execute 'COMMIT TRANSACTION'
         end
 
-        def rollback_to_savepoint(name = current_savepoint_name)
-          disable_auto_reconnect { do_execute "ROLLBACK TRANSACTION #{name}" }
+        def rollback_db_transaction
+          do_execute 'ROLLBACK TRANSACTION'
         end
 
-        def add_limit_offset!(_sql, _options)
-          raise NotImplementedError, 'This has been moved to the SQLServerCompiler in Arel.'
+        include Savepoints
+
+        def create_savepoint(name = current_savepoint_name)
+          do_execute "SAVE TRANSACTION #{name}"
         end
 
-        def empty_insert_statement_value
-          'DEFAULT VALUES'
+        def rollback_to_savepoint(name = current_savepoint_name)
+          do_execute "ROLLBACK TRANSACTION #{name}"
         end
 
-        def case_sensitive_modifier(node)
-          node.acts_like?(:string) ? Arel::Nodes::Bin.new(node) : node
+        def release_savepoint(name = current_savepoint_name)
+        end
+
+        def case_sensitive_modifier(node, table_attribute)
+          node = Arel::Nodes.build_quoted node, table_attribute
+          Arel::Nodes::Bin.new(node)
         end
 
         # === SQLServer Specific ======================================== #
@@ -114,15 +122,23 @@ module ActiveRecord
           end
         end
 
+        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
+        ensure
+          set_identity_insert(table_name, false)
+        end
+
         def use_database(database = nil)
           return if sqlserver_azure?
-          database ||= @connection_options[:database]
-          do_execute "USE #{quote_database_name(database)}" unless database.blank?
+          name = SQLServer::Utils.extract_identifiers(database || @connection_options[:database]).quoted
+          do_execute "USE #{name}" unless name.blank?
         end
 
         def user_options
           return {} if sqlserver_azure?
-          select_rows('DBCC USEROPTIONS WITH NO_INFOMSGS', 'SCHEMA').reduce(HashWithIndifferentAccess.new) do |values, row|
+          select_rows('dbcc useroptions', 'SCHEMA').reduce(HashWithIndifferentAccess.new) do |values, row|
             if row.instance_of? Hash
               set_option = row.values[0].gsub(/\s+/, '_')
               user_value = row.values[1]
@@ -135,7 +151,6 @@ module ActiveRecord
           end
         end
 
-        # TODO: Rails 4 now supports isolation levels
         def user_options_dateformat
           if sqlserver_azure?
             select_value 'SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID', 'SCHEMA'
@@ -169,19 +184,6 @@ module ActiveRecord
           end
         end
 
-        def run_with_isolation_level(isolation_level)
-          unless valid_isolation_levels.include?(isolation_level.upcase)
-            raise ArgumentError, "Invalid isolation level, #{isolation_level}. Supported levels include #{valid_isolation_levels.to_sentence}."
-          end
-          initial_isolation_level = user_options_isolation_level || 'READ COMMITTED'
-          do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}"
-          begin
-            yield
-          ensure
-            do_execute "SET TRANSACTION ISOLATION LEVEL #{initial_isolation_level}"
-          end if block_given?
-        end
-
         def newid_function
           select_value 'SELECT NEWID()'
         end
@@ -190,51 +192,6 @@ module ActiveRecord
           select_value 'SELECT NEWSEQUENTIALID()'
         end
 
-        def activity_stats
-          select_all %|
-            SELECT
-               [session_id]    = s.session_id,
-               [user_process]  = CONVERT(CHAR(1), s.is_user_process),
-               [login]         = s.login_name,
-               [database]      = ISNULL(db_name(r.database_id), N''),
-               [task_state]    = ISNULL(t.task_state, N''),
-               [command]       = ISNULL(r.command, N''),
-               [application]   = ISNULL(s.program_name, N''),
-               [wait_time_ms]  = ISNULL(w.wait_duration_ms, 0),
-               [wait_type]     = ISNULL(w.wait_type, N''),
-               [wait_resource] = ISNULL(w.resource_description, N''),
-               [blocked_by]    = ISNULL(CONVERT (varchar, w.blocking_session_id), ''),
-               [head_blocker]  =
-                    CASE
-                        -- session has an active request, is blocked, but is blocking others
-                        WHEN r2.session_id IS NOT NULL AND r.blocking_session_id = 0 THEN '1'
-                        -- session is idle but has an open tran and is blocking others
-                        WHEN r.session_id IS NULL THEN '1'
-                        ELSE ''
-                    END,
-               [total_cpu_ms]   = s.cpu_time,
-               [total_physical_io_mb]   = (s.reads + s.writes) * 8 / 1024,
-               [memory_use_kb]  = s.memory_usage * 8192 / 1024,
-               [open_transactions] = ISNULL(r.open_transaction_count,0),
-               [login_time]     = s.login_time,
-               [last_request_start_time] = s.last_request_start_time,
-               [host_name]      = ISNULL(s.host_name, N''),
-               [net_address]    = ISNULL(c.client_net_address, N''),
-               [execution_context_id] = ISNULL(t.exec_context_id, 0),
-               [request_id]     = ISNULL(r.request_id, 0),
-               [workload_group] = N''
-            FROM sys.dm_exec_sessions s LEFT OUTER JOIN sys.dm_exec_connections c ON (s.session_id = c.session_id)
-            LEFT OUTER JOIN sys.dm_exec_requests r ON (s.session_id = r.session_id)
-            LEFT OUTER JOIN sys.dm_os_tasks t ON (r.session_id = t.session_id AND r.request_id = t.request_id)
-            LEFT OUTER JOIN
-            (SELECT *, ROW_NUMBER() OVER (PARTITION BY waiting_task_address ORDER BY wait_duration_ms DESC) AS row_num
-                FROM sys.dm_os_waiting_tasks
-            ) w ON (t.task_address = w.waiting_task_address) AND w.row_num = 1
-            LEFT OUTER JOIN sys.dm_exec_requests r2 ON (r.session_id = r2.blocking_session_id)
-            WHERE db_name(r.database_id) = '#{current_database}'
-            ORDER BY s.session_id|
-        end
-
         # === SQLServer Specific (Rake/Test Helpers) ==================== #
 
         def recreate_database
@@ -244,21 +201,25 @@ module ActiveRecord
         end
 
         def recreate_database!(database = nil)
-          current_db = current_database
-          database ||= current_db
-          this_db = database.to_s == current_db
-          do_execute 'USE master' if this_db
+          database ||= current_database
           drop_database(database)
           create_database(database)
         ensure
-          use_database(current_db) if this_db
+          use_database(database)
         end
 
         def drop_database(database)
           retry_count = 0
           max_retries = 1
+          name = SQLServer::Utils.extract_identifiers(database)
           begin
-            do_execute "DROP DATABASE #{quote_database_name(database)}"
+            do_execute "
+              USE master
+              IF EXISTS (
+                SELECT * FROM [sys].[databases]
+                WHERE name = #{quote(name.object)}
+              ) DROP DATABASE #{name}
+            ".squish
           rescue ActiveRecord::StatementInvalid => err
             if err.message =~ /because it is currently in use/i
               raise if retry_count >= max_retries
@@ -273,12 +234,19 @@ module ActiveRecord
           end
         end
 
-        def create_database(database, collation = @connection_options[:collation])
-          if collation
-            do_execute "CREATE DATABASE #{quote_database_name(database)} COLLATE #{collation}"
-          else
-            do_execute "CREATE DATABASE #{quote_database_name(database)}"
+        def create_database(database, options = {})
+          name = SQLServer::Utils.extract_identifiers(database)
+          options = {collation: @connection_options[:collation]}.merge!(options.symbolize_keys)
+          options = options.select { |_, v| v.present? }
+          option_string = options.inject("") do |memo, (key, value)|
+            memo += case key
+            when :collation
+              " COLLATE #{value}"
+            else
+              ""
+            end
           end
+          do_execute "CREATE DATABASE #{name}#{option_string}"
         end
 
         def current_database
@@ -289,6 +257,7 @@ module ActiveRecord
           select_value "SELECT SERVERPROPERTY('SqlCharSetName')"
         end
 
+
         protected
 
         def select(sql, name = nil, binds = [])
@@ -296,71 +265,82 @@ module ActiveRecord
         end
 
         def sql_for_insert(sql, pk, id_value, sequence_name, binds)
-          sql =
-            if pk
-              sql.insert(sql.index(/ (DEFAULT )?VALUES/), " OUTPUT inserted.#{pk}")
-            else
-              "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
-            end
+          sql = if pk
+            quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
+            sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+          else
+            "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+          end
           super
         end
 
         # === SQLServer Specific ======================================== #
 
-        def valid_isolation_levels
-          ['READ COMMITTED', 'READ UNCOMMITTED', 'REPEATABLE READ', 'SERIALIZABLE', 'SNAPSHOT']
+        def binds_have_identity_column?(binds)
+          binds.any? do |column_value|
+            column, value = column_value
+            SQLServerColumn === column && column.is_identity?
+          end
+        end
+
+        def table_name_from_binds(binds)
+          binds.detect { |column_value|
+            column, value = column_value
+            SQLServerColumn === column
+          }.try(:first).try(:table_name)
+        end
+
+        def set_identity_insert(table_name, enable = true)
+          do_execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+        rescue Exception
+          raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
         end
 
         # === SQLServer Specific (Executing) ============================ #
 
         def do_execute(sql, name = 'SQL')
-          log(sql, name) do
-            with_sqlserver_error_handling { raw_connection_do(sql) }
-          end
+          log(sql, name) { raw_connection_do(sql) }
         end
 
-        def do_exec_query(sql, name, binds, options = {})
-          # This allows non-AR code to utilize the binds
-          # handling code, e.g. select_rows()
-          if options[:fetch] != :rows
-            options[:ar_result] = true
-          end
+        def sp_executesql(sql, name, binds, options = {})
+          options[:ar_result] = true if options[:fetch] != :rows
+          types, params = sp_executesql_types_and_parameters(binds)
+          sql = sp_executesql_sql(sql, types, params, name)
+          raw_select sql, name, binds, options
+        end
 
-          explaining = name == 'EXPLAIN'
-          names_and_types = []
-          params = []
+        def sp_executesql_types_and_parameters(binds)
+          types, params = [], []
           binds.each_with_index do |(column, value), index|
-            ar_column = column.is_a?(ActiveRecord::ConnectionAdapters::Column)
-            next if ar_column && column.sql_type == 'timestamp'
-            v = value
-            names_and_types << if ar_column
-                                 if column.is_integer? && value.present?
-                                   v = value.to_i
-                                   # Reset the casted value to the bind as required by Rails 4.1
-                                   binds[index] = [column, v]
-                                 end
-                                 "@#{index} #{column.sql_type_for_statement}"
-                               elsif column.acts_like?(:string)
-                                 "@#{index} nvarchar(max)"
-                               elsif column.is_a?(Fixnum)
-                                 v = value.to_i
-                                 "@#{index} int"
-                               else
-                                 raise 'Unknown bind columns. We can account for this.'
-                               end
-            quoted_value = ar_column ? quote(v, column) : quote(v, nil)
-            params << (explaining ? quoted_value : "@#{index} = #{quoted_value}")
+            types << "@#{index} #{sp_executesql_sql_type(column, value)}"
+            params << quote(value, column)
           end
-          if explaining
-            params.each_with_index do |param, index|
+          [types, params]
+        end
+
+        def sp_executesql_sql_type(column, value)
+          return column.sql_type_for_statement if SQLServerColumn === column
+          if value.is_a?(Numeric)
+            'int'
+          # We can do more here later.
+          else
+            'nvarchar(max)'
+          end
+        end
+
+        def sp_executesql_sql(sql, types, params, name)
+          if name == 'EXPLAIN'
+            params.each.with_index do |param, index|
               substitute_at_finder = /(@#{index})(?=(?:[^']|'[^']*')*$)/ # Finds unquoted @n values.
               sql.sub! substitute_at_finder, param
             end
           else
+            types = quote(types.join(', '))
+            params = params.map.with_index{ |p, i| "@#{i} = #{p}" }.join(', ') # Only p is needed, but with @i helps explain regexp.
             sql = "EXEC sp_executesql #{quote(sql)}"
-            sql << ", #{quote(names_and_types.join(', '))}, #{params.join(', ')}" unless binds.empty?
+            sql << ", #{types}, #{params}" unless params.empty?
           end
-          raw_select sql, name, binds, options
+          sql
         end
 
         def raw_connection_do(sql)
@@ -388,13 +368,11 @@ module ActiveRecord
         end
 
         def raw_connection_run(sql)
-          with_sqlserver_error_handling do
-            case @connection_options[:mode]
-            when :dblib
-              @connection.execute(sql)
-            when :odbc
-              block_given? ? @connection.run_block(sql) { |handle| yield(handle) } : @connection.run(sql)
-            end
+          case @connection_options[:mode]
+          when :dblib
+            @connection.execute(sql)
+          when :odbc
+            block_given? ? @connection.run_block(sql) { |handle| yield(handle) } : @connection.run(sql)
           end
         end
 
@@ -450,6 +428,7 @@ module ActiveRecord
           end
           handle
         end
+
       end
     end
   end