Version bump to 8.0.3.odbc to support ODBC

- ActiveRecord SQLServer Adapter defaults to TinyTDS. And the support for ODBC has been removed. This is the effort to support Adapter with ODBC Driver again.

- ruby-odbc is now pointed to https://github.com/cloudvolumes/ruby-odbc 0.103.cv

Author: jyothu

CHANGELOG.md

@@ -1,3 +1,9 @@
+## v8.0.3.odbc
+
+#### Added
+
+- ODBC restoration.
+
 ## v8.0.3
 
 #### Fixed

Gemfile

@@ -59,6 +59,10 @@ group :tinytds do
 end
 # rubocop:enable Bundler/DuplicatedGem
 
+group :odbc do
+  gem 'ruby-odbc', :git => 'https://github.com/cloudvolumes/ruby-odbc.git', :tag => '0.103.cv'
+end
+
 group :development do
   gem "minitest-spec-rails"
   gem "mocha"

Rakefile

@@ -9,20 +9,29 @@ task test: ["test:dblib"]
 task default: [:test]
 
 namespace :test do
-  ENV["ARCONN"] = "sqlserver"
-
-  %w(dblib).each do |mode|
+  %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 = false
     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"].each do |mode|
+  ["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", "")

VERSION

@@ -1 +1 @@
-8.0.3
+8.0.3.odbc

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

@@ -0,0 +1,29 @@
+module ActiveRecord
+  module ConnectionAdapters
+    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

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -39,6 +39,8 @@ def cast_result(raw_result)
         end
 
         def affected_rows(raw_result)
+          return 0 if raw_result.blank?
+
           column_name = lowercase_schema_reflection ? 'affectedrows' : 'AffectedRows'
           raw_result.first[column_name]
         end
@@ -53,7 +55,7 @@ def raw_execute(sql, name = nil, binds = [], prepare: false, async: false, allow
         end
 
         def internal_exec_sql_query(sql, conn)
-          handle = internal_raw_execute(sql, conn)
+          handle = raw_connection_run(sql, conn)
           handle_to_names_and_values(handle, ar_result: true)
         ensure
           finish_statement_handle(handle)
@@ -168,17 +170,8 @@ def execute_procedure(proc_name, *variables)
 
           log(sql, "Execute Procedure") do |notification_payload|
             with_raw_connection do |conn|
-              result = internal_raw_execute(sql, conn)
-              verified!
-              options = { as: :hash, cache_rows: true, timezone: ActiveRecord.default_timezone || :utc }
-
-              result.each(options) do |row|
-                r = row.with_indifferent_access
-                yield(r) if block_given?
-              end
-
-              result = result.each.map { |row| row.is_a?(Hash) ? row.with_indifferent_access : row }
-              notification_payload[:row_count] = result.count
+              result = send("execute_#{@config[:mode]}_procedure", sql, conn)
+              notification_payload[:row_count] = result&.count
               result
             end
           end
@@ -312,7 +305,11 @@ def sql_for_insert(sql, pk, binds, returning)
         # === SQLServer Specific ======================================== #
 
         def set_identity_insert(table_name, conn, enable)
-          internal_raw_execute("SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}", conn , perform_do: true)
+          if @config[:mode].to_sym == :dblib
+            internal_raw_execute("SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}", conn , perform_do: true)
+          else
+            internal_raw_execute_odbc("SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}", conn , perform_do: true)
+          end
         rescue Exception
           raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
         end
@@ -427,13 +424,26 @@ def identity_columns(table_name)
         # === SQLServer Specific (Selecting) ============================ #
 
         def _raw_select(sql, conn)
-          handle = internal_raw_execute(sql, conn)
+          handle = raw_connection_run(sql, conn)
           handle_to_names_and_values(handle, fetch: :rows)
         ensure
           finish_statement_handle(handle)
         end
 
+        def raw_connection_run(sql, conn, perform_do: false)
+          case @config[:mode].to_sym
+          when :dblib
+            internal_raw_execute(sql, conn, perform_do: perform_do)
+          when :odbc
+            internal_raw_execute_odbc(sql, conn, perform_do: perform_do)
+          end
+        end
+
         def handle_to_names_and_values(handle, options = {})
+          send("handle_to_names_and_values_#{@config[:mode]}", handle, options)
+        end
+
+        def handle_to_names_and_values_dblib(handle, options = {})
           query_options = {}.tap do |qo|
             qo[:timezone] = ActiveRecord.default_timezone || :utc
             qo[:as] = (options[:ar_result] || options[:fetch] == :rows) ? :array : :hash
@@ -448,8 +458,31 @@ def handle_to_names_and_values(handle, options = {})
           options[:ar_result] ? ActiveRecord::Result.new(columns, results) : results
         end
 
+        def handle_to_names_and_values_odbc(handle, options = {})
+          @raw_connection.use_utc = ActiveRecord.default_timezone || :utc
+
+          if options[:ar_result]
+            columns = lowercase_schema_reflection ? handle.columns(true).map { |c| c.name.downcase } : handle.columns(true).map { |c| c.name }
+            rows = handle.fetch_all || []
+            ActiveRecord::Result.new(columns, rows)
+          else
+            case options[:fetch]
+            when :all
+              handle.each_hash || []
+            when :rows
+              handle.fetch_all || []
+            end
+          end
+        end
+
         def finish_statement_handle(handle)
-          handle.cancel if handle
+          case @config[:mode].to_sym
+          when :dblib
+            handle.cancel if handle
+          when :odbc
+            handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
+          end
+
           handle
         end
 
@@ -462,6 +495,55 @@ def internal_raw_execute(sql, raw_connection, perform_do: false)
 
           perform_do ? result.do : result
         end
+
+        # Executing SQL for ODBC mode
+        def internal_raw_execute_odbc(sql, raw_connection, perform_do: false)
+          raw_connection.do(sql) if perform_do
+
+          block_given? ? raw_connection.run_block(sql) { |handle| yield(handle) } : raw_connection.run(sql)
+        end
+
+        private
+
+        def execute_dblib_procedure(sql, conn)
+          result = internal_raw_execute(sql, conn)
+          verified!
+          options = { as: :hash, cache_rows: true, timezone: ActiveRecord.default_timezone || :utc }
+
+          raw_rows = result.each(options).map do |row|
+            row = row.with_indifferent_access
+            yield(row) if block_given?
+            row
+          end
+
+          raw_rows.map { |row| row.is_a?(Hash) ? row.with_indifferent_access : row }
+        end
+
+        def execute_odbc_procedure(sql, conn)
+          results = []
+
+          internal_raw_execute_odbc(sql, conn) do |handle|
+
+            get_rows = lambda do
+              rows = handle_to_names_and_values handle, fetch: :all
+              rows.each_with_index { |r, i| rows[i] = r.with_indifferent_access }
+              results << rows
+            end
+
+            get_rows.call
+            get_rows.call while handle_more_results?(handle)
+          end
+
+          results.many? ? results : results.first
+        end
+
+        def handle_more_results?(handle)
+          case @config[:mode].to_sym
+          when :dblib
+          when :odbc
+            handle.more_results
+          end
+        end
       end
     end
   end