activerecord-sqlserver-adapter 2.3.1 → 2.3.2

data/CHANGELOG

@@ -1,6 +1,18 @@
 
 MASTER
 
+2.3.2
+
+* Insert queries that include the word "insert" as a partial column name with the word 
+  "id" as a value were falsely being matched as identity inserts. [Sean Caffery/bfabry]
+
+* Delegate all low level #raw_connection calls to #raw_connection_run and #raw_connection_do
+  which abstract out the low level modes in the connection options at that point. [Ken Collins]
+
+* Remove DBI dependency and go straight ODBC for speed improvement [Erik Bryn]
+
+* Leave order by alone when same column crosses two tables [Ransom Briggs]
+
 
 * 2.3 * (December 1st, 2009)
 

data/README.rdoc

@@ -6,6 +6,7 @@ The SQL Server adapter for rails is back for ActiveRecord 2.2 and up! We are cur
 
 == What's New
 
+* Strict ODBC required! No DBI means around 20% faster!
 * Now supports SQL Server 2008 too!
 * Fully tested under 1.9!!! Correctly encodes/decodes UTF-8 types in ruby 1.9 too.
 * Now supports both rails 2.2 & 2.3!!!
@@ -128,24 +129,16 @@ It is our goal to match the adapter version with each version of rails. However
 
 == Installation
 
-First, you will need Ruby DBI and Ruby ODBC. If you are using the adapter under 1.9, then you need at least ruby-odbc version 0.9996. To my knowledge the ADO DBD for DBI is no longer supported. The installation below is not a comprehensive walk thru on how to get all the required moving parts like FreeTDS installed and/or configured. It will also assume gem installations of both the dependent libraries and the adapter itself.
+You will need Ruby ODBC. If you are using the adapter under 1.9, then you need at least ruby-odbc version 0.9996. Currently ADO modes are not supported since we dropped the unnecessary DBI dependency and transport layer. This was done so we could incorporate other transports such as ADO.NET (w IronRuby) mode in the future or possibly a straight FreeTDS layer. The sky is the limit now and we have a code that can be accept these optional transports. If you are interested in helping, open a ticket and submit a patch. Or start a conversation on the Google Group.
 
-It should be noted that this version of the adapter was developed using both the ancient 0.0.23 version of DBI up to the current stable release of 0.4.1. Note that DBI 0.4.1 is the minimal for ruby 1.9 compatibility. Because later versions of DBI will be changing many things, IT IS HIGHLY NECESSARY that you max your install to version 0.4.1 which the examples below show. For the time being we are not supporting DBI versions higher than 0.4.1 this they settle down on new internal implementations.
-
-  $ gem install dbi --version 0.4.1
-  $ gem install dbd-odbc --version 0.2.4
   $ gem install activerecord-sqlserver-adapter
 
 Optionally configure your gem dependencies in your rails environment.rb file.
 
-  config.gem 'dbi', :version => '0.4.1'
-  config.gem 'dbd-odbc', :version => '0.2.4', :lib => 'dbd/ODBC'
-  config.gem 'activerecord-sqlserver-adapter', :version => 'x.x.xx', 
-                                               :lib => 'active_record/connection_adapters/sqlserver_adapter'
+  config.gem 'activerecord-sqlserver-adapter', :version => 'x.x.xx'
 
 Here are some external links for libraries and/or tutorials on how to install any other additional components to use this adapter. If you know of a good one that we can include here, just let us know.
 
-* http://ruby-dbi.sourceforge.net/
 * http://www.ch-werner.de/rubyodbc/
 
 

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -1,6 +1,5 @@
+require 'active_record'
 require 'active_record/connection_adapters/abstract_adapter'
-require_library_or_gem 'dbi' unless defined?(DBI)
-require 'active_record/connection_adapters/sqlserver_adapter/core_ext/dbi'
 require 'active_record/connection_adapters/sqlserver_adapter/core_ext/active_record'
 require 'base64'
 
@@ -9,21 +8,22 @@ module ActiveRecord
   class Base
     
     def self.sqlserver_connection(config) #:nodoc:
-      config.symbolize_keys!
-      mode        = config[:mode] ? config[:mode].to_s.upcase : 'ADO'
-      username    = config[:username] ? config[:username].to_s : 'sa'
-      password    = config[:password] ? config[:password].to_s : ''
-      if mode == "ODBC"
-        raise ArgumentError, "Missing DSN. Argument ':dsn' must be set in order for this adapter to work." unless config.has_key?(:dsn)
-        dsn       = config[:dsn]
-        driver_url = "DBI:ODBC:#{dsn}"
+      config = config.dup.symbolize_keys!
+      config.reverse_merge! :mode => :odbc, :host => 'localhost', :username => 'sa', :password => ''
+      mode = config[:mode].to_s.downcase.underscore.to_sym
+      case mode
+      when :odbc
+        require_library_or_gem 'odbc' unless defined?(ODBC)
+        require 'active_record/connection_adapters/sqlserver_adapter/core_ext/odbc'
+        raise ArgumentError, 'Missing :dsn configuration.' unless config.has_key?(:dsn)
+        config = config.slice :dsn, :username, :password
+      when :ado
+        raise NotImplementedError, 'Please use version 2.3.1 of the adapter for ADO connections. Future versions may support ADO.NET.'
+        raise ArgumentError, 'Missing :database configuration.' unless config.has_key?(:database)
       else
-        raise ArgumentError, "Missing Database. Argument ':database' must be set in order for this adapter to work." unless config.has_key?(:database)
-        database  = config[:database]
-        host      = config[:host] ? config[:host].to_s : 'localhost'
-        driver_url = "DBI:ADO:Provider=SQLOLEDB;Data Source=#{host};Initial Catalog=#{database};User ID=#{username};Password=#{password};"
+        raise ArgumentError, "Unknown connection mode in #{config.inspect}."
       end
-      ConnectionAdapters::SQLServerAdapter.new(logger, [driver_url, username, password])
+      ConnectionAdapters::SQLServerAdapter.new(logger,config.merge(:mode=>mode))
     end
     
     protected
@@ -147,53 +147,30 @@ module ActiveRecord
       
     end #SQLServerColumn
     
-    # In ADO mode, this adapter will ONLY work on Windows systems, since it relies on 
-    # Win32OLE, which, to my knowledge, is only available on Windows.
-    #
-    # This mode also relies on the ADO support in the DBI module. If you are using the
-    # one-click installer of Ruby, then you already have DBI installed, but the ADO module 
-    # is *NOT* installed. You will need to get the latest source distribution of Ruby-DBI 
-    # from http://ruby-dbi.sourceforge.net/ unzip it, and copy the file from 
-    # <tt>src/lib/dbd_ado/ADO.rb</tt> to <tt>X:/Ruby/lib/ruby/site_ruby/1.8/DBD/ADO/ADO.rb</tt>
-    # 
-    # You will more than likely need to create the ADO directory. Once you've installed 
-    # that file, you are ready to go.
-    # 
-    # In ODBC mode, the adapter requires the ODBC support in the DBI module which requires
-    # the Ruby ODBC module. Ruby ODBC 0.996 was used in development and testing,
-    # and it is available at http://www.ch-werner.de/rubyodbc/
+    # In ODBC mode, the adapter requires Ruby ODBC and requires that you specify 
+    # a :dsn option. Ruby ODBC is available at http://www.ch-werner.de/rubyodbc/
     #
     # Options:
     #
-    # * <tt>:mode</tt>          -- ADO or ODBC. Defaults to ADO.
     # * <tt>:username</tt>      -- Defaults to sa.
-    # * <tt>:password</tt>      -- Defaults to empty string.
-    # * <tt>:windows_auth</tt>  -- Defaults to "User ID=#{username};Password=#{password}"
-    #
-    # ADO specific options:
-    #
-    # * <tt>:host</tt>          -- Defaults to localhost.
-    # * <tt>:database</tt>      -- The name of the database. No default, must be provided.
-    # * <tt>:windows_auth</tt>  -- Use windows authentication instead of username/password.
-    #
-    # ODBC specific options:
-    #
-    # * <tt>:dsn</tt>           -- Defaults to nothing.
+    # * <tt>:password</tt>      -- Defaults to blank string.
+    # * <tt>:dsn</tt>           -- An ODBC DSN. (required)
     # 
     class SQLServerAdapter < AbstractAdapter
       
-      ADAPTER_NAME            = 'SQLServer'.freeze
-      VERSION                 = '2.3'.freeze
-      DATABASE_VERSION_REGEXP = /Microsoft SQL Server\s+(\d{4})/
-      SUPPORTED_VERSIONS      = [2000,2005,2008].freeze
-      LIMITABLE_TYPES         = ['string','integer','float','char','nchar','varchar','nvarchar'].freeze
-      
-      LOST_CONNECTION_EXCEPTIONS = [DBI::DatabaseError, DBI::InterfaceError]
-      LOST_CONNECTION_MESSAGES = [
-        'Communication link failure',
-        'Read from the server failed',
-        'Write to the server failed',
-        'Database connection was already closed']
+      ADAPTER_NAME                = 'SQLServer'.freeze
+      VERSION                     = '2.3.2'.freeze
+      DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+(\d{4})/
+      SUPPORTED_VERSIONS          = [2000,2005,2008].freeze
+      LIMITABLE_TYPES             = ['string','integer','float','char','nchar','varchar','nvarchar'].freeze
+      LOST_CONNECTION_EXCEPTIONS  = {
+        :odbc => ['ODBC::Error'],
+        :ado  => []
+      }
+      LOST_CONNECTION_MESSAGES    = {
+        :odbc => [/link failure/, /server failed/, /connection was already closed/, /invalid handle/i],
+        :ado  => []
+      }
       
       cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
                      :log_info_schema_queries, :enable_default_unicode_types, :auto_connect
@@ -206,8 +183,8 @@ module ActiveRecord
         
       end
       
-      def initialize(logger, connection_options)
-        @connection_options = connection_options
+      def initialize(logger,config)
+        @connection_options = config
         connect
         super(raw_connection, logger)
         initialize_sqlserver_caches
@@ -349,9 +326,9 @@ module ActiveRecord
       # CONNECTION MANAGEMENT ====================================#
       
       def active?
-        raw_connection.execute("SELECT 1").finish
+        raw_connection_do("SELECT 1")
         true
-      rescue *LOST_CONNECTION_EXCEPTIONS
+      rescue *lost_connection_exceptions
         false
       end
 
@@ -365,8 +342,28 @@ module ActiveRecord
         raw_connection.disconnect rescue nil
       end
       
+      def raw_connection_run(sql)
+        with_auto_reconnect do
+          case connection_mode
+          when :odbc
+            block_given? ? raw_connection.run_block(sql) { |handle| yield(handle) } : raw_connection.run(sql)
+          else :ado
+
+          end
+        end
+      end
+      
+      def raw_connection_do(sql)
+        case connection_mode
+        when :odbc
+          raw_connection.do(sql)
+        else :ado
+          
+        end
+      end
+      
       def finish_statement_handle(handle)
-        handle.finish if handle && handle.respond_to?(:finish) && !handle.finished?
+        handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
         handle
       end
       
@@ -771,22 +768,35 @@ module ActiveRecord
       # CONNECTION MANAGEMENT ====================================#
       
       def connect
-        driver_url, username, password = @connection_options
-        @connection = DBI.connect(driver_url, username, password)
-        configure_connection
+        config = @connection_options
+        @connection = case connection_mode
+                      when :odbc
+                        ODBC.connect config[:dsn], config[:username], config[:password]
+                      when :ado
+                        
+                      end
       rescue
         raise unless @auto_connecting
       end
       
-      def configure_connection
-        raw_connection['AutoCommit'] = true
+      def connection_mode
+        @connection_options[:mode]
+      end
+      
+      def lost_connection_exceptions
+        exceptions = LOST_CONNECTION_EXCEPTIONS[connection_mode]
+        @lost_connection_exceptions ||= exceptions ? exceptions.map(&:constantize) : []
+      end
+      
+      def lost_connection_messages
+        LOST_CONNECTION_MESSAGES[connection_mode]
       end
       
       def with_auto_reconnect
         begin
           yield
-        rescue *LOST_CONNECTION_EXCEPTIONS => e
-          if LOST_CONNECTION_MESSAGES.any? { |lcm| e.message =~ Regexp.new(lcm,Regexp::IGNORECASE) }
+        rescue *lost_connection_exceptions => e
+          if lost_connection_messages.any? { |lcm| e.message =~ lcm }
             retry if auto_reconnected?
           end
           raise
@@ -837,36 +847,22 @@ module ActiveRecord
       end
       
       def raw_execute(sql, name = nil, &block)
-        log(sql, name) do
-          if block_given?
-            with_auto_reconnect { raw_connection.execute(sql) { |handle| yield(handle) } }
-          else
-            with_auto_reconnect { raw_connection.execute(sql) }
-          end
-        end
-      end
-      
-      def without_type_conversion
-        raw_connection.convert_types = false if raw_connection.respond_to?(:convert_types=)
-        yield
-      ensure
-        raw_connection.convert_types = true if raw_connection.respond_to?(:convert_types=)
+        log(sql,name) { raw_connection_run(sql) }
       end
       
       def do_execute(sql,name=nil)
         log(sql, name || 'EXECUTE') do
-          with_auto_reconnect { raw_connection.do(sql) }
+          with_auto_reconnect { raw_connection_do(sql) }
         end
       end
       
       def raw_select(sql, name = nil)
         handle = raw_execute(sql,name)
-        fields = handle.column_names
+        fields = handle.columns(true).map{|c|c.name}
         results = handle_as_array(handle)
         rows = results.inject([]) do |rows,row|
           row.each_with_index do |value, i|
-            # DEPRECATED in DBI 0.4.0 and above. Remove when 0.2.2 and lower is no longer supported.
-            if value.is_a? DBI::Timestamp
+            if value.is_a? ODBC::TimeStamp
               row[i] = value.to_sqlserver_string
             end
           end
@@ -946,7 +942,7 @@ module ActiveRecord
         if insert_sql?(sql)
           table_name = get_table_name(sql)
           id_column = identity_column(table_name)
-          id_column && sql =~ /INSERT[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
+          id_column && sql =~ /^\s*INSERT[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
         else
           false
         end
@@ -1053,7 +1049,7 @@ module ActiveRecord
           WHERE columns.TABLE_NAME = '#{table_name}'
           ORDER BY columns.ordinal_position
         }.gsub(/[ \t\r\n]+/,' ')
-        results = info_schema_query { without_type_conversion{ select(sql,nil,true) } }
+        results = info_schema_query { select(sql,nil,true) }
         results.collect do |ci|
           ci.symbolize_keys!
           ci[:type] = case ci[:type]
@@ -1070,7 +1066,7 @@ module ActiveRecord
             real_table_name = table_name_or_views_table_name(table_name)
             real_column_name = views_real_column_name(table_name,ci[:name])
             col_default_sql = "SELECT c.COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = '#{real_table_name}' AND c.COLUMN_NAME = '#{real_column_name}'"
-            ci[:default_value] = info_schema_query { without_type_conversion{ select_value(col_default_sql) } }
+            ci[:default_value] = info_schema_query { select_value(col_default_sql) }
           end
           ci[:default_value] = case ci[:default_value]
                                when nil, '(null)', '(NULL)'

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

@@ -83,10 +83,11 @@ module ActiveRecord
                                                     else
                                                       [nil, ord_tn_and_cn.first]
                                                     end
-                  if (ord_table_name && ord_table_name == select_table_name && unique_order_hash[ord_column_name]) || unique_order_hash[ord_column_name]
+                  unique_key = [(ord_table_name || select_table_name), ord_column_name]
+                  if unique_order_hash[unique_key]
                     array
                   else
-                    unique_order_hash[ord_column_name] = true
+                    unique_order_hash[unique_key] = true
                     array << "#{ord} #{dir}".strip
                   end
                 end.join(', ')

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

@@ -0,0 +1,41 @@
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServerCoreExtensions
+      module ODBC
+        
+        module TimeStamp
+          def to_sqlserver_string
+            date, time, nanoseconds = to_s.split(' ')
+            "#{date} #{time}.#{sprintf("%03d",nanoseconds.to_i/1000000)}"
+          end
+        end
+        
+        module Statement
+          def finished?
+            begin
+              connected?
+              false
+            rescue ::ODBC::Error => e
+              true
+            end
+          end
+          
+        end
+
+        module Database
+          def run_block(*args)
+            yield sth = run(*args)
+            sth.drop
+          end
+        end
+        
+      end
+    end
+  end
+end
+
+ODBC::TimeStamp.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ODBC::TimeStamp if defined?(ODBC::TimeStamp)
+ODBC::Statement.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ODBC::Statement if defined?(ODBC::Statement)
+ODBC::Database.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ODBC::Database if defined?(ODBC::Database)
+

data/test/cases/adapter_test_sqlserver.rb

@@ -218,6 +218,10 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
         assert_equal 'MIN(comments.id) DESC, MIN(comments.post_id) ASC', order_to_min_set(@two_orders_with_desc_and_asc)
       end
       
+      should 'leave order by alone when same column crosses two tables' do
+        assert_equal ' ORDER BY developers.name, projects.name', add_order!('developers.name, projects.name')
+      end
+      
     end
     
     context 'with different language' do

data/test/cases/connection_test_sqlserver.rb

@@ -12,21 +12,21 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
   end
   
   
-  should 'return finished DBI statment handle from #execute without block' do
+  should 'return finished ODBC statment handle from #execute without block' do
     handle = @connection.execute('SELECT * FROM [topics]')
-    assert_instance_of DBI::StatementHandle, handle
+    assert_instance_of ODBC::Statement, handle
     assert handle.finished?
   end
   
-  should 'finish DBI statment handle from #execute with block' do
+  should 'finish ODBC statment handle from #execute with block' do
     assert_all_statements_used_are_closed do
       @connection.execute('SELECT * FROM [topics]') { }
     end
   end
   
-  should 'return an unfinished DBI statement handler from #raw_execute' do
+  should 'return an unfinished ODBC statement handler from #raw_execute' do
     handle = @connection.send(:raw_execute,'SELECT * FROM [topics]')
-    assert_instance_of DBI::StatementHandle, handle
+    assert_instance_of ODBC::Statement, handle
     assert !handle.finished?
   end
   
@@ -37,7 +37,6 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
   end
   
   should 'affect rows' do
-    assert Topic.connection.instance_variable_get("@connection")["AutoCommit"]
     topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
     updated = Topic.update(topic_data.keys, topic_data.values)
     assert_equal 2, updated.size
@@ -114,15 +113,15 @@ class ConnectionTestSqlserver < ActiveRecord::TestCase
   
   def assert_all_statements_used_are_closed(&block)
     existing_handles = []
-    ObjectSpace.each_object(DBI::StatementHandle) {|handle| existing_handles << handle}
+    ObjectSpace.each_object(ODBC::Statement) {|handle| existing_handles << handle}
     GC.disable
     yield
     used_handles = []
-    ObjectSpace.each_object(DBI::StatementHandle) {|handle| used_handles << handle unless existing_handles.include? handle}
+    ObjectSpace.each_object(ODBC::Statement) {|handle| used_handles << handle unless existing_handles.include? handle}
     assert_block "No statements were used within given block" do
       used_handles.size > 0
     end
-    ObjectSpace.each_object(DBI::StatementHandle) do |handle|
+    ObjectSpace.each_object(ODBC::Statement) do |handle|
       assert_block "Statement should have been closed within given block" do
         handle.finished?
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
-  version: 2.3.1
+  version: 2.3.2
 platform: ruby
 authors: 
 - Ken Collins
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-10 00:00:00 -04:00
+date: 2010-02-15 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -37,7 +37,7 @@ files:
 - lib/activerecord-sqlserver-adapter.rb
 - lib/active_record/connection_adapters/sqlserver_adapter.rb
 - lib/active_record/connection_adapters/sqlserver_adapter/core_ext/active_record.rb
-- lib/active_record/connection_adapters/sqlserver_adapter/core_ext/dbi.rb
+- lib/active_record/connection_adapters/sqlserver_adapter/core_ext/odbc.rb
 has_rdoc: true
 homepage: http://github.com/rails-sqlserver
 licenses: []

data/lib/active_record/connection_adapters/sqlserver_adapter/core_ext/dbi.rb

@@ -1,106 +0,0 @@
-
-module ActiveRecord
-  module ConnectionAdapters
-    module SQLServerCoreExtensions
-      
-      
-      module DBI
-
-        module Timestamp
-          # Deprecated DBI. See documentation for Type::SqlserverTimestamp which 
-          # this method tries to mimic as ODBC is still going to convert SQL Server 
-          # milliconds to whole number representation of nanoseconds.
-          def to_sqlserver_string
-            datetime, nanoseconds = to_s.split('.')
-            "#{datetime}.#{sprintf("%03d",nanoseconds.to_i/1000000)}"
-          end
-        end
-
-        module Type
-
-          # Make sure we get DBI::Type::Timestamp returning a string NOT a time object
-          # that represents what is in the DB before type casting while letting core 
-          # ActiveRecord do the reset. It is assumed that DBI is using ODBC connections 
-          # and that ODBC::Timestamp is taking the native milliseconds that SQL Server 
-          # stores and returning them incorrect using ODBC::Timestamp#fraction which is 
-          # nanoseconds. Below shows the incorrect ODBC::Timestamp represented by DBI 
-          # and the conversion we expect to have in the DB before type casting.
-          # 
-          #   "1985-04-15 00:00:00 0"           # => "1985-04-15 00:00:00.000"
-          #   "2008-11-08 10:24:36 30000000"    # => "2008-11-08 10:24:36.003"
-          #   "2008-11-08 10:24:36 123000000"   # => "2008-11-08 10:24:36.123"
-          class SqlserverTimestamp
-            def self.parse(obj)
-              return nil if ::DBI::Type::Null.parse(obj).nil?
-              date, time, nanoseconds = obj.split(' ')
-              "#{date} #{time}.#{sprintf("%03d",nanoseconds.to_i/1000000)}"
-            end
-          end
-
-          # The adapter and rails will parse our floats, decimals, and money field correctly 
-          # from a string. Do not let the DBI::Type classes create Float/BigDecimal objects 
-          # for us. Trust rails .type_cast to do what it is built to do.
-          class SqlserverForcedString
-            def self.parse(obj)
-              return nil if ::DBI::Type::Null.parse(obj).nil?
-              obj.to_s
-            end
-          end
-          
-          # We want our true 1 to 255 tinyint range.
-          class SqlserverForcedTinyint
-            def self.parse(obj)
-              return nil if ::DBI::Type::Null.parse(obj).nil?
-              obj.to_i
-            end
-          end
-
-        end
-
-        module TypeUtil
-
-          def self.included(klass)
-            klass.extend ClassMethods
-            class << klass
-              alias_method_chain :type_name_to_module, :sqlserver_types
-            end
-          end
-
-          module ClassMethods
-
-            # Capture all types classes that we need to handle directly for SQL Server 
-            # and allow normal processing for those that we do not.
-            def type_name_to_module_with_sqlserver_types(type_name)
-              case type_name
-              when /^timestamp$/i
-                DBI::Type::SqlserverTimestamp
-              when /^float|decimal|money$/i
-                DBI::Type::SqlserverForcedString
-              when /^tinyint$/i
-                DBI::Type::SqlserverForcedTinyint
-              else
-                type_name_to_module_without_sqlserver_types(type_name)
-              end
-            end
-
-          end
-
-        end
-
-      end
-      
-      
-    end
-  end
-end
-
-
-
-
-if defined?(DBI::TypeUtil)
-  DBI::Type.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::DBI::Type
-  DBI::TypeUtil.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::DBI::TypeUtil
-elsif defined?(DBI::Timestamp) # DEPRECATED in DBI 0.4.0 and above. Remove when 0.2.2 and lower is no longer supported.
-  DBI::Timestamp.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::DBI::Timestamp
-end
-