Support upcoming ruby-odbc 0.99992 which returns native datetime objects and can use local/utc time.

Author: metaskills

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -254,29 +254,40 @@ def handle_to_names_and_values(handle, options={})
         end
 
         def handle_to_names_and_values_odbc(handle, options={})
+          @connection.use_utc = ActiveRecord::Base.default_timezone == :utc if @connection_supports_native_types
           case options[:fetch]
           when :all, :one
-            rows = if options[:fetch] == :all
-                     handle.fetch_all || []
-                   else
-                     row = handle.fetch
-                     row ? [row] : [[]]                     
-                   end
-            names = handle.columns(true).map{ |c| c.name }
-            names_and_values = []
-            rows.each do |row|
-              h = {}
-              i = 0
-              while i < row.size
-                v = row[i]
-                h[names[i]] = v.respond_to?(:to_sqlserver_string) ? v.to_sqlserver_string : v
-                i += 1
+            if @connection_supports_native_types
+              if options[:fetch] == :all
+                handle.each_hash || []
+              else
+                row = handle.fetch_hash
+                rows = row ? [row] : [[]]                    
+              end
+            else
+              rows = if options[:fetch] == :all
+                       handle.fetch_all || []
+                     else
+                       row = handle.fetch
+                       row ? [row] : [[]]                     
+                     end
+              names = handle.columns(true).map{ |c| c.name }
+              names_and_values = []
+              rows.each do |row|
+                h = {}
+                i = 0
+                while i < row.size
+                  v = row[i]
+                  h[names[i]] = v.respond_to?(:to_sqlserver_string) ? v.to_sqlserver_string : v
+                  i += 1
+                end
+                names_and_values << h
               end
-              names_and_values << h
+              names_and_values
             end
-            names_and_values
           when :rows
             rows = handle.fetch_all || []
+            return rows if @connection_supports_native_types
             rows.each do |row|
               i = 0
               while i < row.size

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -185,7 +185,8 @@ class SQLServerAdapter < AbstractAdapter
       DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+(\d{4})/
       SUPPORTED_VERSIONS          = [2005,2008].freeze
 
-      attr_reader :database_version, :database_year
+      attr_reader :database_version, :database_year,
+                  :connection_supports_native_types
 
       cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
                      :log_info_schema_queries, :enable_default_unicode_types, :auto_connect,
@@ -352,7 +353,13 @@ def connect
         @connection = case @connection_options[:mode]
                       when :odbc
                         odbc = ['::ODBC','::ODBC_UTF8','::ODBC_NONE'].detect{ |odbc_ns| odbc_ns.constantize rescue nil }.constantize
-                        odbc.connect config[:dsn], config[:username], config[:password]
+                        odbc.connect(config[:dsn], config[:username], config[:password]).tap do |c|
+                          if c.respond_to?(:use_time)
+                            c.use_time = true
+                            c.use_utc = ActiveRecord::Base.default_timezone == :utc
+                            @connection_supports_native_types = true
+                          end
+                        end
                       when :adonet
                         System::Data::SqlClient::SqlConnection.new.tap do |connection|
                           connection.connection_string = System::Data::SqlClient::SqlConnectionStringBuilder.new.tap do |cs|

test/cases/adapter_test_sqlserver.rb

@@ -192,13 +192,13 @@ def setup
 
         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 @db_datetime_003, existing_003.datetime_before_type_cast if existing_003.datetime_before_type_cast.is_a?(String)
           assert_equal 3000, existing_003.datetime.usec, 'A 003 millisecond in SQL Server is 3000 microseconds'
         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 @db_datetime_123, existing_123.datetime_before_type_cast if existing_123.datetime_before_type_cast.is_a?(String)
           assert_equal 123000, existing_123.datetime.usec, 'A 123 millisecond in SQL Server is 123000 microseconds'
         end
 
@@ -209,14 +209,14 @@ def setup
         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 '123', saved.datetime_before_type_cast.split('.')[1] if saved.datetime_before_type_cast.is_a?(String)
           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 '003', saved.datetime_before_type_cast.split('.')[1] if saved.datetime_before_type_cast.is_a?(String)
           assert_equal 3000, saved.datetime.usec
         end
 

test/cases/attribute_methods_test_sqlserver.rb

@@ -17,11 +17,11 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
   fixtures :developers
 
-  # Duplicate with BaseTest#test_read_attributes_before_type_cast_on_datetime
-  # Pick a winer when rails core does the same :/
   def test_coerced_read_attributes_before_type_cast_on_datetime
     developer = Developer.find(:first)
-    assert_equal "#{developer.created_at.to_s(:db)}.000" , developer.attributes_before_type_cast["created_at"]
+    if developer.created_at_before_type_cast.is_a?(String)
+      assert_equal "#{developer.created_at.to_s(:db)}.000" , developer.attributes_before_type_cast["created_at"] 
+    end
   end
 
   def test_coerced_typecast_attribute_from_select_to_false

test/cases/base_test_sqlserver.rb

@@ -1,17 +1,72 @@
 require 'cases/sqlserver_helper'
+require 'models/developer'
+require 'models/project'
+require 'models/company'
+require 'models/customer'
+require 'models/order'
+require 'models/categorization'
+require 'models/category'
+require 'models/post'
+require 'models/author'
+require 'models/tag'
+require 'models/tagging'
+require 'models/parrot'
+require 'models/pirate'
+require 'models/treasure'
+require 'models/price_estimate'
+require 'models/club'
+require 'models/member'
+require 'models/membership'
+require 'models/sponsor'
+require 'models/country'
+require 'models/treaty'
+require 'active_support/core_ext/string/conversions'
 
 class HasAndBelongsToManyAssociationsTestSqlserver < ActiveRecord::TestCase
 end
 
 class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
-  COERCED_TESTS = [:test_count_with_finder_sql]
+  COERCED_TESTS = [
+    :test_count_with_finder_sql,
+    :test_should_record_timestamp_for_join_table
+  ]
 
   include SqlserverCoercedTest
 
+  fixtures :accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects,
+           :parrots, :pirates, :treasures, :price_estimates, :tags, :taggings
+  
+  def setup_data_for_habtm_case
+    ActiveRecord::Base.connection.execute('delete from countries_treaties')
+    country = Country.new(:name => 'India')
+    country.country_id = 'c1'
+    country.save!
+    treaty = Treaty.new(:name => 'peace')
+    treaty.treaty_id = 't1'
+    country.treaties << treaty
+  end
+  
+  
   def test_coerced_count_with_finder_sql
     assert true
   end
 
+  def test_coerced_should_record_timestamp_for_join_table
+    setup_data_for_habtm_case
+    con = ActiveRecord::Base.connection
+    sql = 'select * from countries_treaties'
+    record = con.select_rows(sql).last
+    assert_not_nil record[2]
+    assert_not_nil record[3]
+    if record[2].is_a?(String)
+      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[2]
+      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[3]
+    else
+      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[2].to_s(:db)
+      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[3].to_s(:db)
+    end
+  end
+  
 
 end