rails-sqlserver-2000-2005-adapter 2.2.4 → 2.2.5

data/CHANGELOG

@@ -4,6 +4,20 @@ MASTER
 * 
 
 
+* 2.2.5 (January 4th, 2009)
+
+* Added a log_info_schema_queries class attribute and make all queries to INFORMATION_SCHEMA silent by 
+  default. [Ken Collins]
+
+* Fix millisecond support in datetime columns. ODBC::Timestamp incorrectly takes SQL Server milliseconds
+  and applies them as nanoseconds. We cope with this at the DBI layer by using SQLServerDBI::Type::SqlserverTimestamp 
+  class to parse the before type cast value appropriately. Also update the adapters #quoted_date method 
+  to work more simply by converting ruby's #usec milliseconds to SQL Server microseconds. [Ken Collins]
+
+* Core extensions for ActiveRecord now reflect on the connection before doing SQL Server things. Now 
+  this adapter is compatible for using with other adapters. [Ken Collins]
+
+
 * 2.2.4 (December 5th, 2008)
 
 * Fix a type left in #views_real_column_name. Also cache #view_information lookups. [Ken Collins]

data/README.rdoc

@@ -58,7 +58,7 @@ To pass the ActiveRecord tests we had to implement an class accessor for the nat
 * SQL Server 2000 is 'text'
 * SQL Server 2005 is 'varchar(max)'
 
-During testing this type is set to 'varchar(8000)' for both versions. The reason is that rails expects to be able to use SQL = operators on text data types and this is not possible with a native 'text' data type in SQL Server. The default 'varchar(max)' for SQL Server 2005 can be queried using the SQL = operator and has plenty of storage space which is why we made it the default for 2005. If for some reason you want to change the data type created during migrations for any SQL Server version, you can include this line in your environment.rb file.
+During testing this type is set to 'varchar(8000)' for both versions. The reason is that rails expects to be able to use SQL = operators on text data types and this is not possible with a native 'text' data type in SQL Server. The default 'varchar(max)' for SQL Server 2005 can be queried using the SQL = operator and has plenty of storage space which is why we made it the default for 2005. If for some reason you want to change the data type created during migrations for any SQL Server version, you can configure this line to your liking in a config/initializers file.
 
   ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'varchar(8000)'
 
@@ -68,6 +68,13 @@ By default any :binary column created by migrations will create these native typ
 * SQL Server 2005 is 'varbinary(max)'
 
 
+====  Schema Information Logging
+
+By default all queries to the INFORMATION_SCHEMA table is silenced. If you think logging these queries are useful, you can enable it by adding this like to a config/initializers file.
+
+  ActiveRecord::ConnectionAdapters::SQLServerAdapter.log_info_schema_queries = true
+
+
 == Versions
 
 It is our goal to match the adapter version with each version of rails. However we will track our own tiny version independent of ActiveRecord. For example, an adapter version of 2.2.x will work on any 2.2.x version of ActiveRecord. This convention will be used in both the Git tags as well as the Rubygems versioning.

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -27,7 +27,7 @@ module ActiveRecord
       conn["AutoCommit"] = true
       ConnectionAdapters::SQLServerAdapter.new(conn, logger, [driver_url, username, password])
     end
-   
+    
   end
   
   module ConnectionAdapters
@@ -150,12 +150,12 @@ module ActiveRecord
     class SQLServerAdapter < AbstractAdapter
       
       ADAPTER_NAME            = 'SQLServer'.freeze
-      VERSION                 = '2.2.4'.freeze
+      VERSION                 = '2.2.5'.freeze
       DATABASE_VERSION_REGEXP = /Microsoft SQL Server\s+(\d{4})/
       SUPPORTED_VERSIONS      = [2000,2005].freeze
       LIMITABLE_TYPES         = ['string','integer','float','char','nchar','varchar','nvarchar'].freeze
       
-      cattr_accessor :native_text_database_type, :native_binary_database_type
+      cattr_accessor :native_text_database_type, :native_binary_database_type, :log_info_schema_queries
       
       class << self
         
@@ -189,13 +189,17 @@ module ActiveRecord
       end
       
       def database_version
-        @database_version ||= select_value('SELECT @@version')
+        @database_version ||= info_schema_query { select_value('SELECT @@version') }
       end
       
       def database_year
         DATABASE_VERSION_REGEXP.match(database_version)[1].to_i
       end
       
+      def sqlserver?
+        true
+      end
+      
       def sqlserver_2000?
         database_year == 2000
       end
@@ -260,7 +264,7 @@ module ActiveRecord
       
       def quoted_date(value)
         if value.acts_like?(:time) && value.respond_to?(:usec)
-          "#{super}.#{sprintf("%06d",value.usec)[0..2]}"
+          "#{super}.#{sprintf("%03d",value.usec/1000)}"
         else
           super
         end
@@ -448,18 +452,20 @@ module ActiveRecord
       end
       
       def tables(name = nil)
-        select_values "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME <> 'dtproperties'"
+        info_schema_query do
+          select_values "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME <> 'dtproperties'"
+        end
       end
       
       def views(name = nil)
         @sqlserver_views_cache ||= 
-          select_values "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME NOT IN ('sysconstraints','syssegments')"
+          info_schema_query { select_values("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME NOT IN ('sysconstraints','syssegments')") }
       end
       
       def view_information(table_name)
         table_name = unqualify_table_name(table_name)
         @sqlserver_view_information_cache[table_name] ||= 
-          select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{table_name}'"
+          info_schema_query { select_one("SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{table_name}'") }
       end
       
       def view_table_name(table_name)
@@ -667,6 +673,10 @@ module ActiveRecord
         select_value('SELECT @@ROWCOUNT AS AffectedRows')
       end
       
+      def info_schema_query
+        log_info_schema_queries ? yield : ActiveRecord::Base.silence{ yield }
+      end
+      
       def raw_execute(sql, name = nil, &block)
         log(sql, name) do
           if block_given?
@@ -732,7 +742,7 @@ module ActiveRecord
       # SCHEMA STATEMENTS ========================================#
       
       def remove_check_constraints(table_name, column_name)
-        constraints = select_values("SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{quote_string(table_name)}' and COLUMN_NAME = '#{quote_string(column_name)}'")
+        constraints = info_schema_query { select_values("SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{quote_string(table_name)}' and COLUMN_NAME = '#{quote_string(column_name)}'") }
         constraints.each do |constraint|
           do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(constraint)}"
         end
@@ -888,7 +898,7 @@ module ActiveRecord
           WHERE columns.TABLE_NAME = '#{table_name}'
           ORDER BY columns.ordinal_position
         }.gsub(/[ \t\r\n]+/,' ')
-        results = without_type_conversion { select(sql,nil,true) }
+        results = info_schema_query { without_type_conversion{ select(sql,nil,true) } }
         results.collect do |ci|
           ci.symbolize_keys!
           ci[:type] = case ci[:type]
@@ -905,7 +915,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] = without_type_conversion { select_value(col_default_sql) }
+            ci[:default_value] = info_schema_query { without_type_conversion{ select_value(col_default_sql) } }
           end
           ci[:default_value] = case ci[:default_value]
                                when nil, '(null)', '(NULL)'

data/lib/core_ext/active_record.rb

@@ -29,36 +29,40 @@ module ActiveRecord
         end
         
         def reset_column_information_with_sqlserver_cache_support
-          connection.send(:initialize_sqlserver_caches)
+          connection.send(:initialize_sqlserver_caches) if connection.respond_to?(:sqlserver?)
           reset_column_information_without_sqlserver_cache_support
         end
         
         private
         
         def add_order_with_sqlserver_unique_checking!(sql, order, scope = :auto)
-          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}"
+          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!(order_sql, order, scope)
           end
         end
         

data/lib/core_ext/dbi.rb

@@ -13,20 +13,24 @@ module SQLServerDBI
     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 and let the adapter 
-    # do the reset. DBI::DBD::ODBC will typically return a string like:
+    # 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 547000000"   # => "2008-11-08 10:24:36.547"
-    #   "2008-11-08 10:24:36 123000000"   # => "2008-11-08 10:24:36.000"
+    #   "2008-11-08 10:24:36 300000000"   # => "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, fraction = obj.split(' ')
-        "#{date} #{time}.#{sprintf("%03d",fraction)}"
+        date, time, nanoseconds = obj.split(' ')
+        "#{date} #{time}.#{sprintf("%03d",nanoseconds.to_i/1000000)}"
       end
     end
     

data/test/cases/adapter_test_sqlserver.rb

@@ -199,22 +199,55 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
   context 'For chronic data types' do
     
     context 'with a usec' do
-
+      
       setup do
         @time = Time.now
+        @db_datetime_003 = '2012-11-08 10:24:36.003'
+        @db_datetime_123 = '2012-11-08 10:24:36.123'
+        @all_datetimes = [@db_datetime_003, @db_datetime_123]
+        @all_datetimes.each do |datetime|
+          @connection.execute("INSERT INTO [sql_server_chronics] ([datetime]) VALUES('#{datetime}')")
+        end
       end
       
-      should 'truncate 123456 usec to just 123' do
-        @time.stubs(:usec).returns(123456)
-        saved = SqlServerChronic.create!(:datetime => @time).reload
-        assert_equal 123000, saved.datetime.usec
+      teardown do
+        @all_datetimes.each do |datetime|
+          @connection.execute("DELETE FROM [sql_server_chronics] WHERE [datetime] = '#{datetime}'")
+        end
       end
       
-      should 'drop 123 to 0' do
-        @time.stubs(:usec).returns(123)
-        saved = SqlServerChronic.create!(:datetime => @time).reload
-        assert_equal 0, saved.datetime.usec
-        assert_equal '000', saved.datetime_before_type_cast.split('.').last
+      context 'finding existing DB objects' do
+
+        should 'find 003 millisecond in the DB with before and after casting' do
+          existing_003 = SqlServerChronic.find_by_datetime!(@db_datetime_003)
+          assert_equal @db_datetime_003, existing_003.datetime_before_type_cast
+          assert_equal 3000, existing_003.datetime.usec, 'A 003 millisecond in SQL Server is 3000 milliseconds'
+        end
+
+        should 'find 123 millisecond in the DB with before and after casting' do
+          existing_123 = SqlServerChronic.find_by_datetime!(@db_datetime_123)
+          assert_equal @db_datetime_123, existing_123.datetime_before_type_cast
+          assert_equal 123000, existing_123.datetime.usec, 'A 123 millisecond in SQL Server is 123000 milliseconds'
+        end
+
+      end
+      
+      context 'saving new datetime objects' do
+
+        should 'truncate 123456 usec to just 123 in the DB cast back to 123000' do
+          @time.stubs(:usec).returns(123456)
+          saved = SqlServerChronic.create!(:datetime => @time).reload
+          assert_equal '123', saved.datetime_before_type_cast.split('.')[1]
+          assert_equal 123000, saved.datetime.usec
+        end
+        
+        should 'truncate 3001 usec to just 003 in the DB cast back to 3000' do
+          @time.stubs(:usec).returns(3001)
+          saved = SqlServerChronic.create!(:datetime => @time).reload
+          assert_equal '003', saved.datetime_before_type_cast.split('.')[1]
+          assert_equal 3000, saved.datetime.usec
+        end
+        
       end
       
     end
@@ -440,10 +473,6 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
         end
         
         should 'find default values' do
-          # col_default_sql = "SELECT c.COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = 'string_defaults' AND c.COLUMN_NAME = 'string_with_pretend_null_one'"
-          # raise @connection.select_value(col_default_sql).inspect
-          # raise @connection.without_type_conversion{ @connection.select_value(col_default_sql) }.inspect
-          
           assert_equal 'null', StringDefaultsView.new.pretend_null, 
             StringDefaultsView.columns_hash['pretend_null'].inspect
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rails-sqlserver-2000-2005-adapter
 version: !ruby/object:Gem::Version 
-  version: 2.2.4
+  version: 2.2.5
 platform: ruby
 authors: 
 - Ken Collins
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-25 00:00:00 -08:00
+date: 2009-01-04 00:00:00 -08:00
 default_executable: 
 dependencies: []