activerecord-sqlserver-adapter_new 4.2.15

data/RUNNING_UNIT_TESTS.md

@@ -0,0 +1,121 @@
+
+# How To Run The Test!
+
+This process is much easier than it has been before!
+
+
+## TL;DR
+
+Default testing uses DBLIB with TinyTDS.
+
+* Setup two databases in SQL Server, [activerecord_unittest] and [activerecord_unittest2]
+* Create a [rails] user with an empty password and give it a [db_owner] role to both DBs. Some tests require a server role of [sysadmin] too. More details below with DDL SQL examples.
+* $ bundle install
+* $ bundle exec rake test ACTIVERECORD_UNITTEST_HOST='my.db.net'
+
+Focusing tests. Use the `ONLY_` env vars to run either ours or the ActiveRecord cases. Use the `TEST_FILES` env variants to focus on specific test(s), use commas for multiple cases. Note, you have to use different env vars to focus only on ours or a core ActiveRecord case. There may be failures when focusing on an ActiveRecord case since our coereced test files is not loaded in this scenerio.
+
+```
+$ bundle exec rake test ONLY_SQLSERVER=1
+$ bundle exec rake test ONLY_ACTIVERECORD=1
+
+$ bundle exec rake test TEST_FILES="test/cases/adapter_test_sqlserver.rb"
+$ bundle exec rake test TEST_FILES_AR="test/cases/finder_test.rb"
+```
+
+
+## Creating the test databases
+
+The default names for the test databases are `activerecord_unittest` and `activerecord_unittest2`. If you want to use another database name then be sure to update the connection file that matches your connection method in test/connections/native_sqlserver_#{connection_method}/connection.rb. Define a user named 'rails' in SQL Server with all privileges granted for the test databases. Use an empty password for said user.
+
+The connection files make certain assumptions. For instance, the ODBC connection assumes you have a DSN setup that matches the name of the default database names. Remember too you have to set an environment variable for the DSN of the adapter, see the connection.rb file that matches your connection mode for details.
+
+```sql
+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
+```
+
+## Cloning The Repos
+
+The tests of this adapter depend on the existence of the Rails which are automatically cloned for you with bundler. However you can clone Rails from git://github.com/rails/rails.git and set the `RAILS_SOURCE` environment variable so bundler will use another local path instead.
+
+```
+$ git clone git://github.com/rails-sqlserver/activerecord-sqlserver-adapter.git
+```
+
+Suggest just letting bundler do all the work and assuming there is a git tag for the Rails version, you can set `RAILS_VERSION` before bundling.
+
+```
+$ export RAILS_VERSION='4.2.0'
+$ bundle install
+```
+
+
+## Configure DB Connection
+
+Please consult the `test/config.yml` file which is used to parse the configuration options for the DB connections when running tests. This file has overrides for any connection mode that you can set using simple environment variables. Assuming you are using FreeTDS 0.91 and above
+
+```
+$ export ACTIVERECORD_UNITTEST_HOST='my.db.net'   # Defaults to localhost
+$ export ACTIVERECORD_UNITTEST_PORT='1533'        # Defaults to 1433
+```
+
+If you have FreeTDS installed and/or want to use a named dataserver in your freetds.conf file
+
+```
+$ export ACTIVERECORD_UNITTEST_DATASERVER='mydbname'
+```
+
+These can be passed down to rake too.
+
+```
+$ bundle exec rake test ACTIVERECORD_UNITTEST_HOST='my.db.net'
+```
+
+
+## Bundling
+
+Now with that out of the way you can run "bundle install" to hook everything up. Our tests use bundler to setup the load paths correctly. The default mode is DBLIB using TinyTDS. It is important to use bundle exec so we can wire up the ActiveRecord test libs correctly.
+
+```
+$ bundle exec rake test
+```
+
+
+## Testing Options
+
+The Gemfile contains groups for `:tinytds` and `:odbc`. By default it will install both gems  which allows you to run the full test suite in either connection mode. If for some reason any one of these is problematic or of no concern, you could always opt out of bundling either gem with something like this.
+
+```
+$ bundle install --without odbc
+```
+
+You can run different connection modes using the following rake commands. Again, the DBLIB connection mode using TinyTDS is the default test task.
+
+```
+$ bundle exec rake test:dblib
+$ bundle exec rake test:odbc
+```
+
+By default, Bundler will download the Rails git repo and use the git tag that matches the dependency version in our gemspec. If you want to test another version of Rails, you can either temporarily change the :tag for Rails in the Gemfile. Likewise, you can clone the Rails repo your self to another directory and use the `RAILS_SOURCE` environment variable.
+
+
+## Troubleshooting
+
+* Make sure your firewall is off or allows SQL Server traffic both ways, typically on port 1433.
+* Ensure that you are running on a local admin login to create the Rails user.
+* Possibly change the SQL Server TCP/IP properties in "SQL Server Configuration Manager -> SQL Server Network Configuration -> Protocols for MSSQLSERVER", and ensure that TCP/IP is enabled and the appropriate entries on the "IP Addresses" tab are enabled.
+
+
+## Current Expected Failures
+
+* Misc Date/Time erros when using ODBC mode.

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 = 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', '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/VERSION

@@ -0,0 +1 @@
+4.2.15

data/activerecord-sqlserver-adapter_new.gemspec

@@ -0,0 +1,20 @@
+# -*- 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_new'
+  spec.version       = ActiveRecord::ConnectionAdapters::SQLServer::Version::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.license       = 'MIT'
+  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   = 'ActiveRecord SQL Server Adapter. SQL Server 2012 and upward.'
+  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.1'
+end

data/appveyor.yml

@@ -0,0 +1,39 @@
+init:
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - SET PATH=C:\MinGW\msys\1.0\bin;%PATH%
+  - SET RAKEOPT=-rdevkit
+  - SET TESTOPTS='-v'
+  - SET TINYTDS_VERSION=1.0.4
+clone_depth: 5
+skip_tags: true
+matrix:
+  fast_finish: true
+install:
+  - ps: Update-AppveyorBuild -Version "$(Get-Content $env:appveyor_build_folder\VERSION).$env:appveyor_build_number"
+  - ruby --version
+  - gem --version
+  - bundle install --without odbc guard
+build: off
+test_script:
+  - powershell -File "%APPVEYOR_BUILD_FOLDER%\test\appveyor\dbsetup.ps1"
+  - timeout /t 4 /nobreak > NUL
+  - ps: Start-Service 'MSSQL$SQL2014'
+  - timeout /t 4 /nobreak > NUL
+  - sqlcmd -S ".\SQL2014" -U sa -P Password12! -i %APPVEYOR_BUILD_FOLDER%\test\appveyor\dbsetup.sql
+  - bundle exec rake test ACTIVERECORD_UNITTEST_DATASERVER="localhost\SQL2014"
+  - ps: Stop-Service 'MSSQL$SQL2014'
+  - ps: Start-Service 'MSSQL$SQL2012SP1'
+  - timeout /t 4 /nobreak > NUL
+  - sqlcmd -S ".\SQL2012SP1" -U sa -P Password12! -i %APPVEYOR_BUILD_FOLDER%\test\appveyor\dbsetup.sql
+  - bundle exec rake test ACTIVERECORD_UNITTEST_DATASERVER="localhost\SQL2012SP1"
+  - timeout /t 4 /nobreak > NUL
+  - bundle exec rake test ACTIVERECORD_UNITTEST_HOST=%CI_AZURE_HOST% ACTIVERECORD_UNITTEST_PASS=%CI_AZURE_PASS% ACTIVERECORD_UNITTEST_AZURE=1
+environment:
+  CI_AZURE_HOST:
+    secure: VChrioaIWkf9iuuaSs4cryiA4honrADgZqNC0++begg=
+  CI_AZURE_PASS:
+    secure: cSQp8sk4urJYvq0utpsK+r7J+snJ2wpcdp8RdXJfB+w=
+  matrix:
+    - ruby_version: "200"
+    - ruby_version: "22"
+    - ruby_version: "22-x64"

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

@@ -0,0 +1,27 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module ActiveRecord
+
+          extend ActiveSupport::Concern
+
+          module ClassMethods
+
+            def execute_procedure(proc_name, *variables)
+              if connection.respond_to?(:execute_procedure)
+                connection.execute_procedure(proc_name, *variables)
+              else
+                []
+              end
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end
+
+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

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module Explain
+
+          SQLSERVER_STATEMENT_PREFIX = 'EXEC sp_executesql '
+          SQLSERVER_PARAM_MATCHER = /@\d+ =/
+
+          def exec_explain(queries)
+            unprepared_queries = queries.map { |sql, bind| [unprepare_sqlserver_statement(sql), bind] }
+            super(unprepared_queries)
+          end
+
+          private
+
+          # 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
+          # `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)
+              executesql_args = executesql.split(', ')
+              found_args = executesql_args.reject! { |arg| arg =~ SQLSERVER_PARAM_MATCHER }
+              executesql_args.pop if found_args && executesql_args.many?
+              executesql = executesql_args.join(', ').strip.match(/N'(.*)'/m)[1]
+              Utils.unquote_string(executesql)
+            else
+              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

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

@@ -0,0 +1,4 @@
+silence_warnings do
+  # Already defined in Rails
+  ActiveRecord::ExplainSubscriber::EXPLAINED_SQLS = /(select|update|delete|insert)\b/i
+end

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

@@ -0,0 +1,34 @@
+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

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

@@ -0,0 +1,49 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module DatabaseLimits
+
+        def table_alias_length
+          128
+        end
+
+        def column_name_length
+          128
+        end
+
+        def table_name_length
+          128
+        end
+
+        def index_name_length
+          128
+        end
+
+        def columns_per_table
+          1024
+        end
+
+        def indexes_per_table
+          999
+        end
+
+        def columns_per_multicolumn_index
+          16
+        end
+
+        def in_clause_length
+          65_536
+        end
+
+        def sql_query_length
+          65_536 * 4_096
+        end
+
+        def joins_per_query
+          256
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,386 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module DatabaseStatements
+
+        def select_rows(sql, name = nil, binds = [])
+          sp_executesql sql, name, binds, fetch: :rows
+        end
+
+        def execute(sql, name = nil)
+          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
+        end
+
+        def exec_query(sql, name = 'SQL', binds = [], sqlserver_options = {})
+          sp_executesql(sql, name, binds)
+        end
+
+        def exec_insert(sql, name, binds, _pk = nil, _sequence_name = nil)
+          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)
+          sql << '; SELECT @@ROWCOUNT AS AffectedRows'
+          super.rows.first.first
+        end
+
+        def exec_update(sql, name, binds)
+          sql << '; SELECT @@ROWCOUNT AS AffectedRows'
+          super.rows.first.first
+        end
+
+        def supports_statement_cache?
+          true
+        end
+
+        def begin_db_transaction
+          do_execute 'BEGIN TRANSACTION'
+        end
+
+        def transaction_isolation_levels
+          super.merge snapshot: "SNAPSHOT"
+        end
+
+        def begin_isolated_db_transaction(isolation)
+          set_transaction_isolation_level transaction_isolation_levels.fetch(isolation)
+          begin_db_transaction
+        end
+
+        def set_transaction_isolation_level(isolation_level)
+          do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}"
+        end
+
+        def commit_db_transaction
+          do_execute 'COMMIT TRANSACTION'
+        end
+
+        def exec_rollback_db_transaction
+          do_execute 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION'
+        end
+
+        include Savepoints
+
+        def create_savepoint(name = current_savepoint_name)
+          do_execute "SAVE TRANSACTION #{name}"
+        end
+
+        def exec_rollback_to_savepoint(name = current_savepoint_name)
+          do_execute "ROLLBACK TRANSACTION #{name}"
+        end
+
+        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
+
+        def case_sensitive_comparison(table, attribute, column, value)
+          if column.case_sensitive?
+            table[attribute].eq(value)
+          else
+            super
+          end
+        end
+
+        def case_insensitive_comparison(table, attribute, column, value)
+          if column.case_sensitive?
+            super
+          else
+            table[attribute].eq(value)
+          end
+        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
+          name = 'Execute Procedure'
+          log(sql, name) do
+            case @connection_options[:mode]
+            when :dblib
+              result = @connection.execute(sql)
+              options = { as: :hash, cache_rows: true, timezone: ActiveRecord::Base.default_timezone || :utc }
+              result.each(options) do |row|
+                r = row.with_indifferent_access
+                yield(r) if block_given?
+              end
+              result.each.map { |row| row.is_a?(Hash) ? row.with_indifferent_access : row }
+            when :odbc
+              results = []
+              raw_connection_run(sql) 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
+          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?
+          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', 'SCHEMA').reduce(HashWithIndifferentAccess.new) do |values, row|
+            if row.instance_of? Hash
+              set_option = row.values[0].gsub(/\s+/, '_')
+              user_value = row.values[1]
+            elsif  row.instance_of? Array
+              set_option = row[0].gsub(/\s+/, '_')
+              user_value = row[1]
+            end
+            values[set_option] = user_value
+            values
+          end
+        end
+
+        def user_options_dateformat
+          if sqlserver_azure?
+            select_value 'SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID', 'SCHEMA'
+          else
+            user_options['dateformat']
+          end
+        end
+
+        def user_options_isolation_level
+          if sqlserver_azure?
+            sql = %(SELECT CASE [transaction_isolation_level]
+                    WHEN 0 THEN NULL
+                    WHEN 1 THEN 'READ UNCOMMITTED'
+                    WHEN 2 THEN 'READ COMMITTED'
+                    WHEN 3 THEN 'REPEATABLE READ'
+                    WHEN 4 THEN 'SERIALIZABLE'
+                    WHEN 5 THEN 'SNAPSHOT' END AS [isolation_level]
+                    FROM [sys].[dm_exec_sessions]
+                    WHERE [session_id] = @@SPID).squish
+            select_value sql, 'SCHEMA'
+          else
+            user_options['isolation_level']
+          end
+        end
+
+        def user_options_language
+          if sqlserver_azure?
+            select_value 'SELECT @@LANGUAGE AS [language]', 'SCHEMA'
+          else
+            user_options['language']
+          end
+        end
+
+        def newid_function
+          select_value 'SELECT NEWID()'
+        end
+
+        def newsequentialid_function
+          select_value 'SELECT NEWSEQUENTIALID()'
+        end
+
+
+        protected
+
+        def select(sql, name = nil, binds = [])
+          exec_query(sql, name, binds)
+        end
+
+        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+          sql = if pk && self.class.use_output_inserted && !database_prefix_remote_server?
+            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 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) { raw_connection_do(sql) }
+        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
+
+        def sp_executesql_types_and_parameters(binds)
+          types, params = [], []
+          binds.each_with_index do |(column, value), index|
+            types << "@#{index} #{sp_executesql_sql_type(column, value)}"
+            params << quote(value, column)
+          end
+          [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 << ", #{types}, #{params}" unless params.empty?
+          end
+          sql
+        end
+
+        def raw_connection_do(sql)
+          case @connection_options[:mode]
+          when :dblib
+            @connection.execute(sql).do
+          when :odbc
+            @connection.do(sql)
+          end
+        ensure
+          @update_sql = false
+        end
+
+        # === SQLServer Specific (Selecting) ============================ #
+
+        def raw_select(sql, name = 'SQL', binds = [], options = {})
+          log(sql, name, binds) { _raw_select(sql, options) }
+        end
+
+        def _raw_select(sql, options = {})
+          handle = raw_connection_run(sql)
+          handle_to_names_and_values(handle, options)
+        ensure
+          finish_statement_handle(handle)
+        end
+
+        def raw_connection_run(sql)
+          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
+
+        def handle_more_results?(handle)
+          case @connection_options[:mode]
+          when :dblib
+          when :odbc
+            handle.more_results
+          end
+        end
+
+        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)
+          end
+        end
+
+        def handle_to_names_and_values_dblib(handle, options = {})
+          query_options = {}.tap do |qo|
+            qo[:timezone] = ActiveRecord::Base.default_timezone || :utc
+            qo[:as] = (options[:ar_result] || options[:fetch] == :rows) ? :array : :hash
+          end
+          results = handle.each(query_options)
+          columns = lowercase_schema_reflection ? handle.fields.map { |c| c.downcase } : handle.fields
+          options[:ar_result] ? ActiveRecord::Result.new(columns, results) : results
+        end
+
+        def handle_to_names_and_values_odbc(handle, options = {})
+          @connection.use_utc = ActiveRecord::Base.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)
+          case @connection_options[:mode]
+          when :dblib
+            handle.cancel if handle
+          when :odbc
+            handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
+          end
+          handle
+        end
+
+      end
+    end
+  end
+end