Pass all tests for DBLIB/TinyTDS connection mode and current state of rails 3.1.

Author: metaskills

Gemfile

@@ -26,5 +26,8 @@ group :development do
     gem 'ruby-prof', '0.9.1'
     gem 'ruby-debug', '0.10.3'
   end
+  platforms :mri_19 do
+    gem 'ruby-debug19', '0.11.6'
+  end
 end
 

RUNNING_UNIT_TESTS

@@ -59,10 +59,6 @@ on a local branch of our remote tracking branch.
 
 = Current Expected Failures
 
-* test_count_explicit_columns(RelationTest) <0> expected but was <7>
-  I believe this failure is actually incorrect for other DBs to be passing and 
-  will explore a patch to rails which disables ambiguous results sets.
-
 * Misc Date/Time object instance matches when using ODBC mode.
 
 

Rakefile

@@ -11,9 +11,13 @@ def test_libs(mode='odbc')
 end
 
 def test_files
-  Dir.glob("test/cases/**/*_test_sqlserver.rb").sort + 
-  (Dir.glob("#{ENV['RAILS_SOURCE']}/activerecord/test/cases/**/*_test.rb") - 
-   Dir.glob("#{ENV['RAILS_SOURCE']}/activerecord/test/cases/adapters/**/*_test.rb")).sort
+  files = Dir.glob("test/cases/**/*_test_sqlserver.rb").sort
+  unless ENV['ACTIVERECORD_UNITTEST_SKIP']
+    ar_cases = Dir.glob("#{ENV['RAILS_SOURCE']}/activerecord/test/cases/**/*_test.rb")
+    adapter_cases = Dir.glob("#{ENV['RAILS_SOURCE']}/activerecord/test/cases/adapters/**/*_test.rb")
+    files << (ar_cases-adapter_cases).sort
+  end
+  files
 end
 
 

lib/active_record/connection_adapters/sqlserver/core_ext/active_record.rb

@@ -16,9 +16,6 @@ module ActiveRecord
             class_attribute :coerced_sqlserver_date_columns, :coerced_sqlserver_time_columns
             self.coerced_sqlserver_date_columns = Set.new
             self.coerced_sqlserver_time_columns = Set.new
-            class << self
-              alias_method_chain :reset_column_information, :sqlserver_cache_support
-            end
           end
 
           module ClassMethods
@@ -39,11 +36,6 @@ def coerce_sqlserver_time(*attributes)
               self.coerced_sqlserver_time_columns += attributes.map(&:to_s)
             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
-
           end
 
         end

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -3,26 +3,39 @@ module ConnectionAdapters
     module Sqlserver
       module DatabaseStatements
 
-        def select_one(sql, name = nil)
-          result = raw_select sql, name, :fetch => :one
-          (result && result.first.present?) ? result.first : nil
-        end
-        
         def select_rows(sql, name = nil)
-          raw_select sql, name, :fetch => :rows
+          raw_select sql, name, [], :fetch => :rows
         end
 
-        def execute(sql, name = nil, skip_logging = false)
+        def execute(sql, name = nil)
           if id_insert_table_name = query_requires_identity_insert?(sql)
             with_identity_insert_enabled(id_insert_table_name) { do_execute(sql,name) }
           else
             do_execute(sql,name)
           end
         end
+        
+        def exec_query(sql, name = 'SQL', binds = [])
+          return raw_select(sql, name, binds, :ar_result => true) if binds.empty?
+          if id_insert_table_name = query_requires_identity_insert?(sql)
+            with_identity_insert_enabled(id_insert_table_name) { do_exec_query(sql, name, binds) }
+          else
+            do_exec_query(sql, name, binds)
+          end
+        end
+        
+        def exec_insert(sql, name, binds)
+          sql = "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+          exec_query(sql, name, binds)
+        end
 
         def outside_transaction?
           info_schema_query { select_value("SELECT @@TRANCOUNT") == 0 }
         end
+        
+        def supports_statement_cache?
+          true
+        end
 
         def begin_db_transaction
           do_execute "BEGIN TRANSACTION"
@@ -55,8 +68,8 @@ def empty_insert_statement_value
           "DEFAULT VALUES"
         end
 
-        def case_sensitive_equality_operator
-          cs_equality_operator
+        def case_sensitive_modifier(node)
+          node.acts_like?(:string) ? Arel::Nodes::Bin.new(node) : node
         end
 
         def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
@@ -190,8 +203,8 @@ def charset
 
         protected
 
-        def select(sql, name = nil)
-          raw_select sql, name, :fetch => :all
+        def select(sql, name = nil, binds = [])
+          exec_query(sql, name, binds).to_a
         end
 
         def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
@@ -230,6 +243,32 @@ def do_execute(sql, name = nil)
           end
         end
 
+        def do_exec_query(sql, name, binds)
+          statement = quote(sql)
+          names_and_types = []
+          params = []
+          binds.each_with_index do |(column,value),index|
+            ar_column = column.is_a?(ActiveRecord::ConnectionAdapters::Column)
+            next if ar_column && column.sql_type == 'timestamp'
+            v = value
+            names_and_types << if ar_column
+                                 v = value.to_i if column.is_integer?
+                                 "@#{index} #{column.sql_type_for_statement}"
+                               elsif column.acts_like?(:string)
+                                 "@#{index} nvarchar(max)"
+                               elsif column.is_a?(Fixnum)
+                                 v = value.to_i
+                                 "@#{index} int"
+                               else
+                                 raise "Unknown bind columns. We can account for this."
+                               end
+            quoted_value = ar_column ? quote(v,column) : quote(v,nil)
+            params << "@#{index} = #{quoted_value}"
+          end
+          sql = "EXEC sp_executesql #{statement}, #{quote(names_and_types.join(', '))}, #{params.join(', ')}"
+          raw_select sql, name, binds, :ar_result => true
+        end
+        
         def raw_connection_do(sql)
           case @connection_options[:mode]
           when :dblib
@@ -246,8 +285,8 @@ def raw_connection_do(sql)
 
         # === SQLServer Specific (Selecting) ============================ #
 
-        def raw_select(sql, name=nil, options={})
-          log(sql,name) do
+        def raw_select(sql, name=nil, binds=[], options={})
+          log(sql,name,binds) do
             begin
               handle = raw_connection_run(sql)
               handle_to_names_and_values(handle, options)
@@ -294,12 +333,13 @@ def handle_to_names_and_values(handle, options={})
         def handle_to_names_and_values_dblib(handle, options={})
           query_options = {}.tap do |qo|
             qo[:timezone] = ActiveRecord::Base.default_timezone || :utc
-            qo[:first] = true if options[:fetch] == :one
-            qo[:as] = options[:fetch] == :rows ? :array : :hash
+            qo[:as] = (options[:ar_result] || options[:fetch] == :rows) ? :array : :hash
           end
-          handle.each(query_options)
+          results = handle.each(query_options)
+          options[:ar_result] ? ActiveRecord::Result.new(handle.fields, results) : results
         end
 
+        # TODO [Rails31] Use options[:ar_result]
         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]
@@ -347,12 +387,12 @@ def handle_to_names_and_values_odbc(handle, options={})
           end
         end
 
+        # TODO [Rails31] Use options[:ar_result]
         def handle_to_names_and_values_adonet(handle, options={})
           if handle.has_rows
             names = []
             rows = []
             fields_named = options[:fetch] == :rows
-            one_row_only = options[:fetch] == :one
             while handle.read
               row = []
               handle.visible_field_count.times do |row_index|
@@ -371,7 +411,6 @@ def handle_to_names_and_values_adonet(handle, options={})
                         end
                 row << value
                 names << handle.get_name(row_index).to_s unless fields_named
-                break if one_row_only
               end
               rows << row
               fields_named = true

lib/active_record/connection_adapters/sqlserver/query_cache.rb

@@ -15,6 +15,8 @@ def quote(value, column = nil)
             else
               super
             end
+          when nil
+            column.respond_to?(:sql_type) && column.sql_type == 'timestamp' ? 'DEFAULT' : super
           else
             super
           end
@@ -32,6 +34,14 @@ def quote_column_name(name)
         def quote_table_name(name)
           quote_column_name(name)
         end
+        
+        def substitute_at(column, index)
+          if column.respond_to?(:sql_type) && column.sql_type == 'timestamp'
+            nil
+          else
+            Arel.sql "@#{index}"
+          end
+        end
 
         def quoted_true
           QUOTED_TRUE

lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -39,8 +39,8 @@ def indexes(table_name, name = nil)
 
         def columns(table_name, name = nil)
           return [] if table_name.blank?
-          cache_key = columns_cache_key(table_name)
-          @sqlserver_columns_cache[cache_key] ||= column_definitions(table_name).collect do |ci|
+          cache_key = unqualify_table_name(table_name)
+          column_definitions(table_name).collect do |ci|
             sqlserver_options = ci.except(:name,:default_value,:type,:null).merge(:database_year=>database_year)
             SQLServerColumn.new ci[:name], ci[:default_value], ci[:type], ci[:null], sqlserver_options
           end
@@ -198,11 +198,11 @@ def column_definitions(table_name)
               ELSE 1
             END as is_identity
             FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS columns
-            WHERE columns.TABLE_NAME = '#{table_name}'
+            WHERE columns.TABLE_NAME = @0
               AND columns.TABLE_SCHEMA = #{table_schema.nil? ? "schema_name() " : "'#{table_schema}' "}
             ORDER BY columns.ordinal_position
           }.gsub(/[ \t\r\n]+/,' ')
-          results = info_schema_query { select(sql,nil) }
+          results = info_schema_query { do_exec_query(sql, 'InfoSchema::ColumnDefinitions', [['table_name', table_name]]) }
           results.collect do |ci|
             ci = ci.symbolize_keys
             ci[:type] = case ci[:type]
@@ -351,12 +351,10 @@ def columns_cache_key(table_name)
 
         def remove_sqlserver_columns_cache_for(table_name)
           cache_key = unqualify_table_name(table_name)
-          @sqlserver_columns_cache[cache_key] = nil
           initialize_sqlserver_caches(false)
         end
 
         def initialize_sqlserver_caches(reset_columns=true)
-          @sqlserver_columns_cache = {} if reset_columns
           @sqlserver_views_cache = nil
           @sqlserver_view_information_cache = {}
           @sqlserver_quoted_column_and_table_names = {}
@@ -388,7 +386,7 @@ def with_identity_insert_enabled(table_name)
 
         def set_identity_insert(table_name, enable = true)
           sql = "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
-          do_execute(sql,'IDENTITY_INSERT')
+          do_execute sql,'InfoSchema::SetIdentityInsert'
         rescue Exception => e
           raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
         end

lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -5,7 +5,6 @@
 require 'active_record/connection_adapters/sqlserver/database_limits'
 require 'active_record/connection_adapters/sqlserver/database_statements'
 require 'active_record/connection_adapters/sqlserver/errors'
-require 'active_record/connection_adapters/sqlserver/query_cache'
 require 'active_record/connection_adapters/sqlserver/schema_statements'
 require 'active_record/connection_adapters/sqlserver/quoting'
 require 'active_support/core_ext/kernel/requires'
@@ -61,7 +60,7 @@ def self.did_lose_sqlserver_connection(connection)
   module ConnectionAdapters
 
     class SQLServerColumn < Column
-            
+
       def initialize(name, default, sql_type = nil, null = true, sqlserver_options = {})
         @sqlserver_options = sqlserver_options.symbolize_keys
         super(name, default, sql_type, null)
@@ -87,6 +86,14 @@ def is_utf8?
         @sql_type =~ /nvarchar|ntext|nchar/i
       end
 
+      def is_integer?
+        @sql_type =~ /int/i
+      end
+      
+      def sql_type_for_statement
+        is_integer? ? sql_type.sub(/\(\d+\)/,'') : sql_type
+      end
+      
       def default_function
         @sqlserver_options[:default_function]
       end
@@ -160,7 +167,6 @@ class SQLServerAdapter < AbstractAdapter
       include Sqlserver::DatabaseStatements
       include Sqlserver::SchemaStatements
       include Sqlserver::DatabaseLimits
-      include Sqlserver::QueryCache
       include Sqlserver::Errors
 
       ADAPTER_NAME                = 'SQLServer'.freeze
@@ -265,6 +271,11 @@ def reset!
         remove_database_connections_and_rollback { }
       end
 
+      def clear_cache!
+        # This requires db admin perms and I'm not even sure it is a good idea.
+        # raw_connection_do "DBCC FREEPROCCACHE WITH NO_INFOMSGS" rescue nil
+      end
+      
       # === Abstract Adapter (Misc Support) =========================== #
 
       def pk_and_sequence_for(table_name)
@@ -331,7 +342,7 @@ def native_binary_database_type
       end
 
       def cs_equality_operator
-        @@cs_equality_operator || 'COLLATE Latin1_General_CS_AS_WS ='
+        @@cs_equality_operator || 'COLLATE Latin1_General_CS_AS_WS'
       end