rails-sqlserver-2000-2005-adapter 2.2.19 → 2.2.21

data/CHANGELOG

@@ -1,6 +1,35 @@
 
 MASTER
 
+* 
+
+
+* 2.2.21 * (September 10th, 2009)
+
+* Changes for gem best practices per http://weblog.rubyonrails.org/2009/9/1/gem-packaging-best-practices
+  Details of such are as follows: [Ken Collins]
+  - Removed rails-sqlserver-2000-2005-adapter.rb load file for old github usage.
+  - Move the core_ext directory to active_record/connection_adapters/sqlserver_adapter/core_ext
+  - Renamespace SQLServerDBI to ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::DBI
+  - Renamespace ActiveRecord::ConnectionAdapters::SQLServerActiveRecordExtensions to ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ActiveRecord
+
+
+* 2.2.20 * (September 10th, 2009)
+
+* Implement a new remove_default_constraint method that uses sp_helpconstraint [Ken Collins]
+
+* Use a lazy match in add_order_by_for_association_limiting! to allow sub selects to be used. Resolves 
+  ticket #11.
+
+* Add default rake task back for testing. Runs the namespaced sqlserver:test_sqlserver_odbc. 
+  Resolves ticket #10 [Ken Collins]
+
+* Default value detection in column_definitions is kinder to badly formatted, or long winded user
+  defined functions, for default values. Resolves ticket #8 [Ken Collins]
+
+* Make sure bigint SQL Server data type can be used and converted back to Bignum as expected. [Ken Collins]
+
+
 * 2.2.19 * (June 19th, 2009)
 
 * Leave quoted column names as is. Resolves ticket #36 [Vince Puzzella]

data/README.rdoc

@@ -150,10 +150,9 @@ Here are some external links for libraries and/or tutorials on how to install an
 
 == Contributing
 
-If you’d like to contribute a feature or bugfix, thanks! To make sure your fix/feature has a high chance of being added, please read the following guidelines. First, ask on the Google list, IRC, or post a ticket in Lighthouse. Second, make sure there are tests! We will not accept any patch that is not tested. Please read the RUNNING_UNIT_TESTS file for the details of how to run the unit tests.
+If you’d like to contribute a feature or bugfix, thanks! To make sure your fix/feature has a high chance of being added, please read the following guidelines. First, ask on the Google list, IRC, or post a ticket on github issues. Second, make sure there are tests! We will not accept any patch that is not tested. Please read the RUNNING_UNIT_TESTS file for the details of how to run the unit tests.
 
 * Github: http://github.com/rails-sqlserver
-* Lighthouse: http://rails-sqlserver.lighthouseapp.com/projects/20277-sql-server-05-adapter/tickets
 * Google Group: http://groups.google.com/group/rails-sqlserver-adapter
 * IRC Room: #rails-sqlserver on irc.freenode.net
 

data/RUNNING_UNIT_TESTS

@@ -5,12 +5,19 @@ The default names for the test databases are "activerecord_unittest" and
 to update the connection adapter setups you want to test with in 
 test/connections/<your database>/connection.rb. 
 
+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.
+
 
 == Requirements
 
 The following gems need to be installed. Make sure you have gems.github.com as a
-source. http://github.com/blog/97-github-loves-rubygems-1-2
+source. Info here. http://gems.github.com/
+
+We use echoe for packagemanagement to rubyforge. Not needed really for the tests 
+but since we need it... you need to install it.
 
+  * gem install echoe
   * gem install thoughtbot-shoulda -s http://gems.github.com
   * gem install mocha
 
@@ -21,11 +28,8 @@ is assumed to exist:
 #{RAILS_ROOT}/vendor/plugins/adapters/sqlserver
 #{RAILS_ROOT}/vendor/rails/activerecord/test
 
-Define a user named 'rails' in SQL Server with all privileges granted. Use an empty 
-password for user 'rails', or alternatively use the OSQLPASSWORD environment variable
-which allows you to set a default password for the current session.
-
-Then run "rake create_databases".
+Define a user named 'rails' in SQL Server with all privileges granted for the 
+test databases. Use an empty password for said user.
 
 
 == Running with Rake

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake'
 require 'rake/testtask'
 require 'echoe'
 
-Echoe.new('activerecord-sqlserver-adapter','2.2.19') do |p|
+Echoe.new('activerecord-sqlserver-adapter','2.2.21') do |p|
   p.summary               = "SQL Server 2000, 2005 and 2008 Adapter For Rails."
   p.description           = "SQL Server 2000, 2005 and 2008 Adapter For Rails."
   p.author                = ["Ken Collins","Murray Steele","Shawn Balestracci","Joe Rafaniello","Tom Ward"]
@@ -11,7 +11,7 @@ Echoe.new('activerecord-sqlserver-adapter','2.2.19') do |p|
   p.url                   = "http://github.com/rails-sqlserver"
   p.runtime_dependencies  = ["dbi =0.4.1","dbd-odbc =0.2.4"]
   p.include_gemspec       = false
-  p.ignore_pattern        = ["autotest/*","*.gemspec","lib/rails-sqlserver-2000-2005-adapter.rb"]
+  p.ignore_pattern        = ["autotest/*","*.gemspec"]
   p.project               = 'arsqlserver'
 end
 

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -1,7 +1,7 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require_library_or_gem 'dbi' unless defined?(DBI)
-require 'core_ext/dbi'
-require 'core_ext/active_record'
+require 'active_record/connection_adapters/sqlserver_adapter/core_ext/dbi'
+require 'active_record/connection_adapters/sqlserver_adapter/core_ext/active_record'
 require 'base64'
 
 module ActiveRecord
@@ -183,7 +183,7 @@ module ActiveRecord
     class SQLServerAdapter < AbstractAdapter
       
       ADAPTER_NAME            = 'SQLServer'.freeze
-      VERSION                 = '2.2.19'.freeze
+      VERSION                 = '2.2.21'.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
@@ -698,7 +698,7 @@ module ActiveRecord
         # Disertation http://gist.github.com/24073
         # Information http://weblogs.sqlteam.com/jeffs/archive/2007/12/13/select-distinct-order-by-error.aspx
         return sql if options[:order].blank?
-        columns = sql.match(/SELECT\s+DISTINCT(.*)FROM/)[1].strip
+        columns = sql.match(/SELECT\s+DISTINCT(.*?)FROM/)[1].strip
         sql.sub!(/SELECT\s+DISTINCT/,'SELECT')
         sql << "GROUP BY #{columns} ORDER BY #{order_to_min_set(options[:order])}"
       end
@@ -908,9 +908,10 @@ module ActiveRecord
       end
       
       def remove_default_constraint(table_name, column_name)
-        constraints = select_values("SELECT def.name FROM sysobjects def, syscolumns col, sysobjects tab WHERE col.cdefault = def.id AND col.name = '#{quote_string(column_name)}' AND tab.name = '#{quote_string(table_name)}' AND col.id = tab.id")
-        constraints.each do |constraint|
-          do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(constraint)}"
+        select_all("EXEC sp_helpconstraint '#{quote_string(table_name)}','nomsg'").select do |row|
+          row['constraint_type'] == "DEFAULT on column #{column_name}"
+        end.each do |row|
+          do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{row['constraint_name']}"
         end
       end
       
@@ -1081,7 +1082,8 @@ module ActiveRecord
                                when nil, '(null)', '(NULL)'
                                  nil
                                else
-                                 ci[:default_value].match(/\A\(+N?'?(.*?)'?\)+\Z/)[1]
+                                 match_data = ci[:default_value].match(/\A\(+N?'?(.*?)'?\)+\Z/)
+                                 match_data ? match_data[1] : nil
                                end
           ci[:null] = ci[:is_nullable].to_i == 1 ; ci.delete(:is_nullable)
           ci

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

@@ -0,0 +1,150 @@
+require 'active_record/version'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServerCoreExtensions
+      
+      
+      module ActiveRecord
+
+        def self.included(klass)
+          klass.extend ClassMethods
+          class << klass
+            alias_method_chain :reset_column_information, :sqlserver_cache_support
+            alias_method_chain :add_order!, :sqlserver_unique_checking
+            alias_method_chain :add_limit!, :sqlserver_order_checking
+          end
+        end
+
+        module ClassMethods
+
+          def execute_procedure(proc_name, *variables)
+            if connection.respond_to?(:execute_procedure)
+              connection.execute_procedure(proc_name,*variables)
+            else
+              []
+            end
+          end
+
+          def coerce_sqlserver_date(*attributes)
+            write_inheritable_attribute :coerced_sqlserver_date_columns, Set.new(attributes.map(&:to_s))
+          end
+
+          def coerce_sqlserver_time(*attributes)
+            write_inheritable_attribute :coerced_sqlserver_time_columns, Set.new(attributes.map(&:to_s))
+          end
+
+          def coerced_sqlserver_date_columns
+            read_inheritable_attribute(:coerced_sqlserver_date_columns) || []
+          end
+
+          def coerced_sqlserver_time_columns
+            read_inheritable_attribute(:coerced_sqlserver_time_columns) || []
+          end
+
+          def reset_column_information_with_sqlserver_cache_support
+            connection.send(:initialize_sqlserver_caches) if connection.respond_to?(:sqlserver?)
+            reset_column_information_without_sqlserver_cache_support
+          end
+
+          private
+
+          def add_limit_with_sqlserver_order_checking!(sql, options, scope = :auto)
+            if connection.respond_to?(:sqlserver?)
+              scope = scope(:find) if :auto == scope
+              if scope
+                options = options.dup
+                scoped_order = scope[:order]
+                order = options[:order]
+                if order && scoped_order
+                  options[:order] = add_order_with_sqlserver_unique_checking!('', order, scope).gsub(/^ ORDER BY /,'')
+                elsif scoped_order
+                  options[:order] = scoped_order
+                end
+              end
+            end
+            add_limit_without_sqlserver_order_checking!(sql, options, scope)
+          end
+
+          def add_order_with_sqlserver_unique_checking!(sql, order, scope = :auto)
+            if connection.respond_to?(:sqlserver?)
+              order_sql = ''
+              add_order_without_sqlserver_unique_checking!(order_sql, order, scope)
+              unless order_sql.blank?
+                unique_order_hash = {}
+                select_table_name = connection.send(:get_table_name,sql)
+                select_table_name.tr!('[]','') if select_table_name
+                orders_and_dirs_set = connection.send(:orders_and_dirs_set,order_sql)
+                unique_order_sql = orders_and_dirs_set.inject([]) do |array,order_dir|
+                  ord, dir = order_dir
+                  ord_tn_and_cn = ord.to_s.split('.').map{|o|o.tr('[]','')}
+                  ord_table_name, ord_column_name = if ord_tn_and_cn.size > 1
+                                                      ord_tn_and_cn
+                                                    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]
+                    array
+                  else
+                    unique_order_hash[ord_column_name] = true
+                    array << "#{ord} #{dir}".strip
+                  end
+                end.join(', ')
+                sql << " ORDER BY #{unique_order_sql}"
+              end
+            else
+              add_order_without_sqlserver_unique_checking!(sql, order, scope)
+            end
+          end
+
+        end
+        
+        module JoinAssociationChanges
+          
+          def self.included(klass)
+            klass.class_eval do
+              include InstanceMethods
+              alias_method_chain :aliased_table_name_for, :sqlserver_support
+            end
+          end
+
+          module InstanceMethods
+
+            protected
+
+            # An exact copy, except this method has a Regexp escape on the quoted table name.
+            def aliased_table_name_for_with_sqlserver_support(name,suffix=nil)
+              if !parent.table_joins.blank? && parent.table_joins.to_s.downcase =~ %r{join(\s+\w+)?\s+#{Regexp.escape(active_record.connection.quote_table_name(name.downcase))}\son}i
+                @join_dependency.table_aliases[name] += 1
+              end
+              unless @join_dependency.table_aliases[name].zero?
+                # if the table name has been used, then use an alias
+                name = active_record.connection.table_alias_for "#{pluralize(reflection.name)}_#{parent_table_name}#{suffix}"
+                table_index = @join_dependency.table_aliases[name]
+                @join_dependency.table_aliases[name] += 1
+                name = name[0..active_record.connection.table_alias_length-3] + "_#{table_index+1}" if table_index > 0
+              else
+                @join_dependency.table_aliases[name] += 1
+              end
+              name
+            end
+
+          end
+          
+        end
+        
+      end
+      
+      
+    end
+  end
+end
+
+
+ActiveRecord::Base.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ActiveRecord
+
+if ActiveRecord::VERSION::MAJOR == 2 && ActiveRecord::VERSION::MINOR >= 3
+  require 'active_record/associations'
+  ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ActiveRecord::JoinAssociationChanges
+end
+

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

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

data/test/cases/specific_schema_test_sqlserver.rb

@@ -50,7 +50,24 @@ class SpecificSchemaTestSqlserver < ActiveRecord::TestCase
 
     end
     
+    context 'with bigint column' do
 
+      setup do
+        @b5k   = 5000
+        @bi5k  = @edge_class.create! :bigint => @b5k, :description => 'Five Thousand'
+        @bnum  = 9_000_000_000_000_000_000
+        @bimjr = @edge_class.create! :bigint => @bnum, :description => 'Close to max bignum'
+      end
+
+      should 'can find by biginit' do
+        assert_equal @bi5k,  @edge_class.find_by_bigint(@b5k)
+        assert_equal @b5k,   @edge_class.find(:first, :select => 'bigint', :conditions => {:bigint => @b5k}).bigint
+        assert_equal @bimjr, @edge_class.find_by_bigint(@bnum)
+        assert_equal @bnum,  @edge_class.find(:first, :select => 'bigint', :conditions => {:bigint => @bnum}).bigint
+      end
+
+    end
+    
   end
   
   

data/test/schema/sqlserver_specific_schema.rb

@@ -64,6 +64,7 @@ ActiveRecord::Schema.define do
   
   create_table :sql_server_edge_schemas, :force => true do |t|
     t.string :description
+    t.column :bigint, :bigint
   end
   
   execute "IF EXISTS (SELECT TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = 'customers_view') DROP VIEW customers_view"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rails-sqlserver-2000-2005-adapter
 version: !ruby/object:Gem::Version 
-  version: 2.2.19
+  version: 2.2.21
 platform: ruby
 authors: 
 - Ken Collins
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-18 00:00:00 -07:00
+date: 2009-09-10 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -35,10 +35,9 @@ files:
 - autotest/discover.rb
 - autotest/railssqlserver.rb
 - autotest/sqlserver.rb
-- lib/rails-sqlserver-2000-2005-adapter.rb
 - lib/active_record/connection_adapters/sqlserver_adapter.rb
-- lib/core_ext/active_record.rb
-- lib/core_ext/dbi.rb
+- lib/active_record/connection_adapters/sqlserver_adapter/core_ext/active_record.rb
+- lib/active_record/connection_adapters/sqlserver_adapter/core_ext/dbi.rb
 has_rdoc: true
 homepage: http://github.com/rails-sqlserver
 post_install_message: 

data/lib/core_ext/active_record.rb

@@ -1,151 +0,0 @@
-require 'active_record/version'
-
-module ActiveRecord
-  module ConnectionAdapters
-    module SQLServerActiveRecordExtensions
-      
-      def self.included(klass)
-        klass.extend ClassMethods
-        class << klass
-          alias_method_chain :reset_column_information, :sqlserver_cache_support
-          alias_method_chain :add_order!, :sqlserver_unique_checking
-          alias_method_chain :add_limit!, :sqlserver_order_checking
-        end
-      end
-      
-      module ClassMethods
-        
-        def execute_procedure(proc_name, *variables)
-          if connection.respond_to?(:execute_procedure)
-            connection.execute_procedure(proc_name,*variables)
-          else
-            []
-          end
-        end
-        
-        def coerce_sqlserver_date(*attributes)
-          write_inheritable_attribute :coerced_sqlserver_date_columns, Set.new(attributes.map(&:to_s))
-        end
-        
-        def coerce_sqlserver_time(*attributes)
-          write_inheritable_attribute :coerced_sqlserver_time_columns, Set.new(attributes.map(&:to_s))
-        end
-        
-        def coerced_sqlserver_date_columns
-          read_inheritable_attribute(:coerced_sqlserver_date_columns) || []
-        end
-        
-        def coerced_sqlserver_time_columns
-          read_inheritable_attribute(:coerced_sqlserver_time_columns) || []
-        end
-        
-        def reset_column_information_with_sqlserver_cache_support
-          connection.send(:initialize_sqlserver_caches) if connection.respond_to?(:sqlserver?)
-          reset_column_information_without_sqlserver_cache_support
-        end
-        
-        private
-        
-        def add_limit_with_sqlserver_order_checking!(sql, options, scope = :auto)
-          if connection.respond_to?(:sqlserver?)
-            scope = scope(:find) if :auto == scope
-            if scope
-              options = options.dup
-              scoped_order = scope[:order]
-              order = options[:order]
-              if order && scoped_order
-                options[:order] = add_order_with_sqlserver_unique_checking!('', order, scope).gsub(/^ ORDER BY /,'')
-              elsif scoped_order
-                options[:order] = scoped_order
-              end
-            end
-          end
-          add_limit_without_sqlserver_order_checking!(sql, options, scope)
-        end
-        
-        def add_order_with_sqlserver_unique_checking!(sql, order, scope = :auto)
-          if connection.respond_to?(:sqlserver?)
-            order_sql = ''
-            add_order_without_sqlserver_unique_checking!(order_sql, order, scope)
-            unless order_sql.blank?
-              unique_order_hash = {}
-              select_table_name = connection.send(:get_table_name,sql)
-              select_table_name.tr!('[]','') if select_table_name
-              orders_and_dirs_set = connection.send(:orders_and_dirs_set,order_sql)
-              unique_order_sql = orders_and_dirs_set.inject([]) do |array,order_dir|
-                ord, dir = order_dir
-                ord_tn_and_cn = ord.to_s.split('.').map{|o|o.tr('[]','')}
-                ord_table_name, ord_column_name = if ord_tn_and_cn.size > 1
-                                                    ord_tn_and_cn
-                                                  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]
-                  array
-                else
-                  unique_order_hash[ord_column_name] = true
-                  array << "#{ord} #{dir}".strip
-                end
-              end.join(', ')
-              sql << " ORDER BY #{unique_order_sql}"
-            end
-          else
-            add_order_without_sqlserver_unique_checking!(sql, order, scope)
-          end
-        end
-        
-      end
-      
-    end
-  end
-end
-
-ActiveRecord::Base.send :include, ActiveRecord::ConnectionAdapters::SQLServerActiveRecordExtensions
-
-
-
-
-if ActiveRecord::VERSION::MAJOR == 2 && ActiveRecord::VERSION::MINOR >= 3
-
-  require 'active_record/associations'
-  module ActiveRecord
-    module ConnectionAdapters
-      module SQLServerJoinAssociationChanges
-        
-        def self.included(klass)
-          klass.class_eval do
-            include InstanceMethods
-            alias_method_chain :aliased_table_name_for, :sqlserver_support
-          end
-        end
-        
-        module InstanceMethods
-          
-          protected
-          
-          # An exact copy, except this method has a Regexp escape on the quoted table name.
-          def aliased_table_name_for_with_sqlserver_support(name,suffix=nil)
-            if !parent.table_joins.blank? && parent.table_joins.to_s.downcase =~ %r{join(\s+\w+)?\s+#{Regexp.escape(active_record.connection.quote_table_name(name.downcase))}\son}i
-              @join_dependency.table_aliases[name] += 1
-            end
-            unless @join_dependency.table_aliases[name].zero?
-              # if the table name has been used, then use an alias
-              name = active_record.connection.table_alias_for "#{pluralize(reflection.name)}_#{parent_table_name}#{suffix}"
-              table_index = @join_dependency.table_aliases[name]
-              @join_dependency.table_aliases[name] += 1
-              name = name[0..active_record.connection.table_alias_length-3] + "_#{table_index+1}" if table_index > 0
-            else
-              @join_dependency.table_aliases[name] += 1
-            end
-            name
-          end
-          
-        end
-        
-      end
-    end
-  end
-  ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.send :include, ActiveRecord::ConnectionAdapters::SQLServerJoinAssociationChanges
-
-end
-

data/lib/core_ext/dbi.rb

@@ -1,85 +0,0 @@
-
-module SQLServerDBI
-  
-  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
-    
-  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
-        else
-          type_name_to_module_without_sqlserver_types(type_name)
-        end
-      end
-      
-    end
-    
-  end
-  
-  
-end
-
-
-if defined?(DBI::TypeUtil)
-  DBI::Type.send :include, SQLServerDBI::Type
-  DBI::TypeUtil.send :include, SQLServerDBI::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, SQLServerDBI::Timestamp
-end
-

data/lib/rails-sqlserver-2000-2005-adapter.rb

@@ -1 +0,0 @@
-require 'active_record/connection_adapters/sqlserver_adapter'