activerecord-sqlserver-adapter 2.2.20 → 2.2.21

data/CHANGELOG

@@ -4,6 +4,16 @@ 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]

data/Manifest

@@ -1,8 +1,8 @@
 CHANGELOG
-lib/active_record/connection_adapters/sqlserver_adapter.rb
 lib/activerecord-sqlserver-adapter.rb
-lib/core_ext/active_record.rb
-lib/core_ext/dbi.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
 Manifest
 MIT-LICENSE
 Rakefile

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake'
 require 'rake/testtask'
 require 'echoe'
 
-Echoe.new('activerecord-sqlserver-adapter','2.2.20') 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.20') 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.20'.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

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
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
-  version: 2.2.20
+  version: 2.2.21
 platform: ruby
 authors: 
 - Ken Collins, Murray Steele, Shawn Balestracci, Joe Rafaniello, Tom Ward
@@ -40,18 +40,18 @@ extensions: []
 
 extra_rdoc_files: 
 - CHANGELOG
-- lib/active_record/connection_adapters/sqlserver_adapter.rb
 - lib/activerecord-sqlserver-adapter.rb
-- lib/core_ext/active_record.rb
-- lib/core_ext/dbi.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
 - README.rdoc
 - tasks/sqlserver.rake
 files: 
 - CHANGELOG
-- lib/active_record/connection_adapters/sqlserver_adapter.rb
 - lib/activerecord-sqlserver-adapter.rb
-- lib/core_ext/active_record.rb
-- lib/core_ext/dbi.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
 - Manifest
 - MIT-LICENSE
 - Rakefile

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
-