activerecord-sqlserver-adapter-odbc-extended 8.0.10

data/lib/active_record/connection_adapters/extended_sqlserver_adapter.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    # Extends the ActiveRecord SQL Server adapter with custom behavior
+    # and compatibility fixes for ODBC and SQL Server–specific features.
+    # Provides overrides for query execution, type casting, and schema handling.
+    class SQLServerAdapter
+      class << self
+        def new_client(config)
+          case config[:mode].to_sym
+          when :dblib
+            dblib_connect(config)
+          when :odbc
+            odbc_connect(config)
+          else
+            raise ArgumentError, "Unknown connection mode in #{config.inspect}."
+          end
+        end
+
+        def dblib_connect(config)
+          TinyTds::Client.new(config)
+        rescue TinyTds::Error => e
+          raise ActiveRecord::NoDatabaseError if e.message.match(/database .* does not exist/i)
+
+          raise e.message
+        end
+
+        def odbc_connect(config)
+          raise ArgumentError, "Missing :dsn configuration." unless config.key?(:dsn)
+
+          if config[:dsn].include?(";")
+            driver = ODBC::Driver.new.tap do |d|
+              d.name = config[:dsn_name] || "Driver1"
+              d.attrs = config[:dsn].split("\n").map do |atr|
+                atr.split("=")
+              end.select { |kv| kv.size == 2 }.each_with_object({}) do |e, a|
+                k, v = e
+                a[k] = v
+              end
+            end
+
+            ODBC::Database.new.drvconnect(driver)
+          else
+            ODBC.connect config[:dsn], config[:username], config[:password]
+          end.tap do |c|
+            c.use_time = true
+            c.use_utc = ActiveRecord.default_timezone || :utc
+          rescue StandardError
+            warn "Ruby ODBC v0.99992 or higher is required."
+          end
+        rescue ODBC::Error => e
+          raise ActiveRecord::NoDatabaseError if e.message.match(/database .* does not exist/i)
+
+          raise e.message
+        end
+      end
+
+      def initialize(...)
+        super
+
+        @config[:tds_version] ||= "7.3" if @config[:mode].to_sym == :dblib
+        @config[:appname] = self.class.rails_application_name unless @config[:appname]
+        @config[:login_timeout] = @config[:login_timeout].present? ? @config[:login_timeout].to_i : nil
+        @config[:timeout] = @config[:timeout].present? ? @config[:timeout].to_i / 1000 : nil
+        @config[:encoding] = @config[:encoding].present? ? @config[:encoding] : nil
+
+        @connection_parameters ||= @config
+
+        apply_mode_specific_behavior
+      end
+      # === Abstract Adapter (Connection Management) ================== #
+
+      def active?
+        return false unless @raw_connection
+
+        @connection_parameters[:mode].to_sym == :dblib ? @raw_connection.active? : odbc_connection_active?
+      rescue *connection_errors
+        false
+      end
+
+      def odbc_connection_active?
+        @raw_connection.do("SELECT 1")
+        true
+      rescue *connection_errors
+        false
+      end
+
+      def reconnect
+        case @connection_parameters[:mode].to_sym
+        when :dblib
+          begin
+            @raw_connection&.close
+          rescue StandardError
+            nil
+          end
+        when :odbc
+          begin
+            @raw_connection&.disconnect
+          rescue StandardError
+            nil
+          end
+        end
+
+        @raw_connection = nil
+        @spid = nil
+        @collation = nil
+
+        connect
+      end
+
+      def disconnect!
+        super
+
+        case @connection_parameters[:mode].to_sym
+        when :dblib
+          begin
+            @raw_connection&.close
+          rescue StandardError
+            nil
+          end
+        when :odbc
+          begin
+            @raw_connection&.disconnect
+          rescue StandardError
+            nil
+          end
+        end
+
+        @raw_connection = nil
+        @spid = nil
+        @collation = nil
+      end
+
+      # === SQLServer Specific (Connection Management) ================ #
+
+      protected
+
+      def connection_errors
+        @connection_errors ||= [].tap do |errors|
+          errors << TinyTds::Error if defined?(TinyTds::Error)
+          errors << ODBC::Error if defined?(ODBC::Error)
+        end
+      end
+
+      private
+
+      def configure_connection
+        send("configure_#{@config[:mode]}_connection")
+
+        @spid = _raw_select("SELECT @@SPID", @raw_connection).first.first
+
+        initialize_dateformatter
+        use_database
+      end
+
+      def configure_dblib_connection
+        if @config[:azure]
+          @raw_connection.execute("SET ANSI_NULLS ON").do
+          @raw_connection.execute("SET ANSI_NULL_DFLT_ON ON").do
+          @raw_connection.execute("SET ANSI_PADDING ON").do
+          @raw_connection.execute("SET ANSI_WARNINGS ON").do
+        else
+          @raw_connection.execute("SET ANSI_DEFAULTS ON").do
+        end
+
+        @raw_connection.execute("SET QUOTED_IDENTIFIER ON").do
+        @raw_connection.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
+        @raw_connection.execute("SET IMPLICIT_TRANSACTIONS OFF").do
+        @raw_connection.execute("SET TEXTSIZE 2147483647").do
+        @raw_connection.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
+      end
+
+      def configure_odbc_connection
+        if @config[:azure]
+          @raw_connection.do("SET ANSI_NULLS ON")
+          @raw_connection.do("SET ANSI_NULL_DFLT_ON ON")
+          @raw_connection.do("SET ANSI_PADDING ON")
+          @raw_connection.do("SET ANSI_WARNINGS ON")
+        else
+          @raw_connection.do("SET ANSI_DEFAULTS ON")
+        end
+
+        @raw_connection.do("SET QUOTED_IDENTIFIER ON")
+        @raw_connection.do("SET CURSOR_CLOSE_ON_COMMIT OFF")
+        @raw_connection.do("SET IMPLICIT_TRANSACTIONS OFF")
+        @raw_connection.do("SET TEXTSIZE 2147483647")
+        @raw_connection.do("SET CONCAT_NULL_YIELDS_NULL ON")
+
+        @raw_connection.do("SET LOCK_TIMEOUT 45000")
+      end
+
+      def apply_mode_specific_behavior
+        return if @config[:mode].to_sym != :odbc
+
+        require "odbc"
+        require "active_record/connection_adapters/sqlserver/core_ext/odbc"
+        require "active_record/connection_adapters/sqlserver/odbc_database_statements"
+
+        ActiveRecord::ConnectionAdapters::SQLServerAdapter.prepend SQLServer::OdbcDatabaseStatements
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module ODBC
+          # Adds helper methods for handling ODBC statement objects.
+          # Provides a safe implementation of +finished?+ to check
+          # connection state and handle ODBC errors gracefully.
+          module Statement
+            def finished?
+              connected?
+              false
+            rescue ::ODBC::Error
+              true
+            end
+          end
+
+          # Adds helper methods for ODBC database operations.
+          # Wraps execution blocks to ensure statement handles are
+          # properly released after use, preventing connection leaks.
+          module Database
+            def run_block(*args)
+              sth = run(*args)
+
+              begin
+                yield sth
+              ensure
+                sth.drop if sth&.connected?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ODBC::Statement.include ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::ODBC::Statement
+ODBC::Database.include ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::ODBC::Database

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      # Removes default SQL Server implementations of +exec_update+ and +exec_delete+
+      # so they can be replaced by ODBC-specific versions.
+      # Otherwise, when calling +super+ from the OdbcDatabaseStatements module,
+      # Ruby’s ancestor chain would still include this module and invoke
+      # the original TinyTDS-based methods.
+      module DatabaseStatements
+        remove_method :exec_update
+        remove_method :exec_delete
+      end
+
+      # Module: OdbcDatabaseStatements
+      #
+      # Provides ODBC-specific SQL execution methods for the SQL Server adapter.
+      # This module overrides default DatabaseStatements methods to handle
+      # ODBC driver behavior, such as statement handle cleanup and row count
+      # retrieval through @@ROWCOUNT.
+      #
+      # When included, this module replaces the default TinyTDS-based methods
+      # removed from +DatabaseStatements+, ensuring correct behavior for ODBC
+      # connections and allowing +super+ calls without invoking the removed methods.
+      module OdbcDatabaseStatements
+        def affected_rows(raw_result)
+          return if raw_result.blank?
+
+          column_name = lowercase_schema_reflection ? "affectedrows" : "AffectedRows"
+          raw_result.first[column_name]
+        end
+
+        def internal_exec_sql_query(sql, conn)
+          handle = internal_raw_execute(sql, conn)
+          handle_to_names_and_values(handle, ar_result: true)
+        ensure
+          finish_statement_handle(handle)
+        end
+
+        def exec_delete(sql, name = nil, binds = [])
+          super || super("SELECT @@ROWCOUNT As AffectedRows", "", [])
+        end
+
+        def exec_update(sql, name = nil, binds = [])
+          super || super("SELECT @@ROWCOUNT As AffectedRows", "", [])
+        end
+
+        # === SQLServer Specific ======================================== #
+
+        def execute_procedure(proc_name, *variables)
+          vars = if variables.any? && variables.first.is_a?(Hash)
+                   variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
+                 else
+                   variables.map { |v| quote(v) }
+                 end.join(", ")
+          sql = "EXEC #{proc_name} #{vars}".strip
+
+          log(sql, "Execute Procedure") do |notification_payload|
+            with_raw_connection do |conn|
+              result = execute_odbc_procedure(sql, conn)
+              notification_payload[:row_count] = result&.count
+              result
+            end
+          end
+        end
+
+        protected
+
+        def sql_for_insert(sql, pk, binds, returning)
+          if pk.nil?
+            table_name = query_requires_identity_insert?(sql)
+            pk = primary_key(table_name)
+          end
+
+          sql = if pk && use_output_inserted? && !database_prefix_remote_server?
+                  table_name ||= get_table_name(sql)
+                  exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
+
+                  if exclude_output_inserted
+                    pk_and_types = Array(pk).map do |subkey|
+                      {
+                        quoted: SQLServer::Utils.extract_identifiers(subkey).quoted,
+                        id_sql_type: exclude_output_inserted_id_sql_type(subkey, exclude_output_inserted)
+                      }
+                    end
+
+                    <<-SQL.strip_heredoc
+                      SET NOCOUNT ON
+                      DECLARE @ssaIdInsertTable table (#{pk_and_types.map { |pk_and_type| "#{pk_and_type[:quoted]} #{pk_and_type[:id_sql_type]}" }.join(", ")});
+                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT #{pk_and_types.map { |pk_and_type| "INSERTED.#{pk_and_type[:quoted]}" }.join(", ")} INTO @ssaIdInsertTable"}
+                      SELECT #{pk_and_types.map { |pk_and_type| "CAST(#{pk_and_type[:quoted]} AS #{pk_and_type[:id_sql_type]}) #{pk_and_type[:quoted]}" }.join(", ")} FROM @ssaIdInsertTable;
+                      SET NOCOUNT OFF
+                    SQL
+                  else
+                    returning_columns = returning || Array(pk)
+
+                    if returning_columns.any?
+                      returning_columns_statements = returning_columns.map { |c| " INSERTED.#{SQLServer::Utils.extract_identifiers(c).quoted}" }
+                      sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i),
+                                     " OUTPUT#{returning_columns_statements.join(",")}"
+                    else
+                      sql
+                    end
+                  end
+                else
+                  table = get_table_name(sql)
+                  id_column = identity_columns(table.to_s.strip).first
+
+                  if id_column.present?
+                    sql.sub(/\s*VALUES\s*\(/, " OUTPUT INSERTED.#{id_column.name} VALUES (")
+                  else
+                    sql.sub(/\s*VALUES\s*\(/, " OUTPUT CAST(SCOPE_IDENTITY() AS bigint) AS Ident VALUES (")
+                  end
+                end
+
+          [sql, binds]
+        end
+
+        # === 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)
+        rescue StandardError
+          raise ActiveRecordError,
+                "IDENTITY_INSERT could not be turned #{enable ? "ON" : "OFF"} for table #{table_name}"
+        end
+
+        def sp_executesql_sql_type(attr)
+          if attr.respond_to?(:type)
+            type = attr.type.is_a?(ActiveRecord::Normalization::NormalizedValueType) ? attr.type.cast_type : attr.type
+            type = type.subtype if type.serialized?
+
+            return type.sqlserver_type if type.respond_to?(:sqlserver_type)
+
+            if type.is_a?(ActiveRecord::Encryption::EncryptedAttributeType) &&
+               type.instance_variable_get(:@cast_type).respond_to?(:sqlserver_type)
+              return type.instance_variable_get(:@cast_type).sqlserver_type
+            end
+          end
+
+          value = active_model_attribute?(attr) ? attr.value_for_database : attr
+
+          if value.is_a?(Numeric)
+            if value.is_a?(Integer)
+              value > 2_147_483_647 ? "bigint" : "int"
+            else
+              # For Float, BigDecimal, Rational etc.
+              value.is_a?(BigDecimal) ? "decimal(18,6)" : "float"
+            end
+          else
+            "nvarchar(max)"
+          end
+        end
+
+        # === SQLServer Specific (Selecting) ============================ #
+
+        def _raw_select(sql, conn)
+          handle = internal_raw_execute(sql, conn)
+          handle_to_names_and_values(handle, fetch: :rows)
+        ensure
+          finish_statement_handle(handle)
+        end
+
+        def handle_to_names_and_values(handle, options = {})
+          @raw_connection.use_utc = ActiveRecord.default_timezone || :utc
+
+          return build_ar_result(handle) if options[:ar_result]
+
+          fetch_handle_data(handle, options[:fetch])
+        end
+
+        def finish_statement_handle(handle)
+          return unless handle
+
+          handle.drop if handle.respond_to?(:drop) && !handle.finished?
+          handle
+        end
+
+        # Executing SQL for ODBC mode
+        def internal_raw_execute(sql, raw_connection, perform_do: false)
+          return raw_connection.do(sql) if perform_do
+
+          block_given? ? raw_connection.run_block(sql) { |handle| yield(handle) } : raw_connection.run(sql)
+        end
+
+        private
+
+        def build_ar_result(handle)
+          columns = extract_column_names(handle)
+          rows = handle.fetch_all || []
+          ActiveRecord::Result.new(columns, rows)
+        end
+
+        def extract_column_names(handle)
+          if lowercase_schema_reflection
+            handle.columns(true).map { |c| c.name.downcase }
+          else
+            handle.columns(true).map(&:name)
+          end
+        end
+
+        def fetch_handle_data(handle, fetch_mode)
+          case fetch_mode
+          when :all
+            handle.each_hash || []
+          when :rows
+            handle.fetch_all || []
+          end
+        end
+
+        def execute_odbc_procedure(sql, conn)
+          results = []
+
+          internal_raw_execute(sql, conn) do |handle|
+            get_rows = lambda do
+              rows = handle_to_names_and_values handle, fetch: :all
+              results << rows.map!(&:with_indifferent_access)
+            end
+
+            get_rows.call
+            get_rows.call while handle_more_results?(handle)
+          end
+
+          results.many? ? results : results.first
+        end
+
+        def handle_more_results?(handle)
+          handle.more_results
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlserver/type/binary_ext.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module Type
+        # Extends SQL Server binary type handling in ActiveRecord.
+        # Adds a custom +cast_value+ implementation to properly encode or
+        # convert binary (varbinary) values from hex strings.
+        class Binary
+          # Custom override to handle binary casting for SQL Server.
+          # Ensures non-frozen strings are forced to binary encoding
+          # or packed from hex when needed.
+          def cast_value(value)
+            if value.instance_of?(::String) && !value.frozen?
+              value.force_encoding(Encoding::BINARY) =~ /[^[:xdigit:]]/ ? value : [value].pack("H*")
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-sqlserver-adapter-odbc-extended.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "odbc_utf8"
+
+# Ensure we only patch after ActiveRecord and the base SQL Server adapter are loaded
+ActiveSupport.on_load(:active_record) do
+  require "activerecord-sqlserver-adapter"
+  require "active_record/connection_adapters/sqlserver_adapter"
+  require "active_record/connection_adapters/sqlserver/type/binary_ext"
+  require "active_record/connection_adapters/extended_sqlserver_adapter"
+end

data/test/appveyor/dbsetup.ps1

@@ -0,0 +1,27 @@
+
+Write-Output "Setting up..."
+[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
+[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.SqlWmiManagement") | Out-Null
+
+Write-Output "Setting variables..."
+$serverName = $env:COMPUTERNAME
+$instanceNames = @('SQL2014')
+$smo = 'Microsoft.SqlServer.Management.Smo.'
+$wmi = new-object ($smo + 'Wmi.ManagedComputer')
+
+Write-Output "Configure Instances..."
+foreach ($instanceName in $instanceNames) {
+  Write-Output "Instance $instanceName ..."
+  Write-Output "Enable TCP/IP and port 1433..."
+  $uri = "ManagedComputer[@Name='$serverName']/ServerInstance[@Name='$instanceName']/ServerProtocol[@Name='Tcp']"
+  $tcp = $wmi.GetSmoObject($uri)
+  $tcp.IsEnabled = $true
+  foreach ($ipAddress in $Tcp.IPAddresses) {
+    $ipAddress.IPAddressProperties["TcpDynamicPorts"].Value = ""
+    $ipAddress.IPAddressProperties["TcpPort"].Value = "1433"
+  }
+  $tcp.Alter()
+}
+
+Set-Service SQLBrowser -StartupType Manual
+Start-Service SQLBrowser

data/test/appveyor/dbsetup.sql

@@ -0,0 +1,11 @@
+CREATE DATABASE [activerecord_unittest];
+CREATE DATABASE [activerecord_unittest2];
+GO
+CREATE LOGIN [rails] WITH PASSWORD = '', CHECK_POLICY = OFF, DEFAULT_DATABASE = [activerecord_unittest];
+GO
+USE [activerecord_unittest];
+CREATE USER [rails] FOR LOGIN [rails];
+GO
+EXEC sp_addrolemember N'db_owner', N'rails';
+EXEC master..sp_addsrvrolemember @loginame = N'rails', @rolename = N'sysadmin'
+GO

data/test/cases/active_schema_test_sqlserver.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class ActiveSchemaTestSQLServer < ActiveRecord::TestCase
+  describe "indexes" do
+    before do
+      connection.create_table :schema_test_table, force: true, id: false do |t|
+        t.column :foo, :string, limit: 100
+        t.column :state, :string
+      end
+    end
+
+    after do
+      connection.drop_table :schema_test_table rescue nil
+    end
+
+    it 'default index' do
+      assert_queries_match('CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo"
+      end
+    end
+
+    it 'unique index' do
+      assert_queries_match('CREATE UNIQUE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo", unique: true
+      end
+    end
+
+    it 'where condition on index' do
+      assert_queries_match("CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo]) WHERE state = 'active'") do
+        connection.add_index :schema_test_table, "foo", where: "state = 'active'"
+      end
+    end
+
+    it 'if index does not exist' do
+      assert_queries_match("IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = 'index_schema_test_table_on_foo') " \
+                 "CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
+        connection.add_index :schema_test_table, "foo", if_not_exists: true
+      end
+    end
+
+    it 'clustered index' do
+      assert_queries_match('CREATE CLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo", type: :clustered
+      end
+    end
+
+    it 'nonclustered index' do
+      assert_queries_match('CREATE NONCLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo", type: :nonclustered
+      end
+    end
+  end
+
+  describe 'collation' do
+    it "create column with NOT NULL and COLLATE" do
+      assert_nothing_raised do
+        connection.create_table :not_null_with_collation_table, force: true, id: false do |t|
+          t.text :not_null_text_with_collation, null: false, collation: "Latin1_General_CS_AS"
+        end
+      end
+    ensure
+      connection.drop_table :not_null_with_collation_table rescue nil
+    end
+  end
+
+  describe 'datetimeoffset precision' do
+    it 'valid precisions are correct' do
+      assert_nothing_raised do
+        connection.create_table :datetimeoffset_precisions do |t|
+          t.datetimeoffset :precision_default
+          t.datetimeoffset :precision_5, precision: 5
+          t.datetimeoffset :precision_7, precision: 7
+        end
+      end
+
+      columns = connection.columns("datetimeoffset_precisions")
+
+      assert_equal columns.find { |column| column.name == "precision_default" }.precision, 7
+      assert_equal columns.find { |column| column.name == "precision_5" }.precision, 5
+      assert_equal columns.find { |column| column.name == "precision_7" }.precision, 7
+    ensure
+      connection.drop_table :datetimeoffset_precisions rescue nil
+    end
+
+    it 'invalid precision raises exception' do
+      assert_raise(ActiveRecord::ActiveRecordError) do
+        connection.create_table :datetimeoffset_precisions do |t|
+          t.datetimeoffset :precision_8, precision: 8
+        end
+      end
+    ensure
+      connection.drop_table :datetimeoffset_precisions rescue nil
+    end
+  end
+
+  describe 'time precision' do
+    it 'valid precisions are correct' do
+      assert_nothing_raised do
+        connection.create_table :time_precisions do |t|
+          t.time :precision_default
+          t.time :precision_5, precision: 5
+          t.time :precision_7, precision: 7
+        end
+      end
+
+      columns = connection.columns("time_precisions")
+
+      assert_equal columns.find { |column| column.name == "precision_default" }.precision, 7
+      assert_equal columns.find { |column| column.name == "precision_5" }.precision, 5
+      assert_equal columns.find { |column| column.name == "precision_7" }.precision, 7
+    ensure
+      connection.drop_table :time_precisions rescue nil
+    end
+
+    it 'invalid precision raises exception' do
+      assert_raise(ActiveRecord::ActiveRecordError) do
+        connection.create_table :time_precisions do |t|
+          t.time :precision_8, precision: 8
+        end
+      end
+    ensure
+      connection.drop_table :time_precisions rescue nil
+    end
+  end
+end