activerecord-sqlserver-adapter 2.3.8 → 2.3.9

data/CHANGELOG

@@ -1,5 +1,20 @@
 
-MASTER
+
+* 2.3.9
+
+* Support DSN'less connections. Resolves ticket 38. 
+
+* Support upcoming ruby odbc 0.99992
+
+* Include new raw connection interfaces developed and optimized under the 3.0 branch.
+
+* The remove_column conforms to ArgumentError exceptions. [Ken Collins]
+
+* Add support for default function values in schema reflection. Allows for uniqueidentifier default 
+values like NEWID(). These are not automatically inserted into the INSERT statement as of yet, that 
+could be done user side on a before save callback now. Includes new #newid_function and 
+#newsequentialid_function on the connection for helping. Resolves tikcet #42. [Ken Collins]
+
 
 * 2.3.8
 

data/RUNNING_UNIT_TESTS

@@ -11,55 +11,17 @@ 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. 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 shoulda
   * gem install mocha
 
-The tests of this adapter depend on the existence of rails checkout. All the tests
-defined by rails are re-used. For this to work the following directory structure 
-is assumed to exist:
-
-#{RAILS_ROOT}/vendor/plugins/adapters/sqlserver
-#{RAILS_ROOT}/vendor/rails/activerecord/test
+The tests of this adapter depend on the existence of rails checkout. Make sure 
+to checkout remotes/origin/2-3-stable, then make sure to export RAILS_SOURCE to 
+the full path of that repo.
 
 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
-
-The easiest way to run the unit tests is through Rake. Either run "rake test" which 
-defaults to ODBC mode or being mode specific using either "rake sqlserver:test:adonet" 
-or "rake sqlserver:test:odbc". For more information, checkout the full array of rake tasks 
-with "rake -T"
-
-Rake can be found at http://rake.rubyforge.org
-
-
-== Running with Autotest
-
-Using autotest is easy, just run "autotest" and the tests will run continually in the 
-same order as the rake test command. By default autotest will use ODBC connection. If 
-you want to change this you can edit the autotest/sqlserver.rb file and set odbc_mode 
-to false.
-
-Lastly, you can run autotest on just the adapter specific tests with "autotest sqlserver". 
-This will continuously run ONLY the SQL Sever specific behavior tests which are much 
-quicker to run than the entire active record test suite.
-
-
-== Running by hand
 
-Unit tests are located in test directory. If you only want to run a single test suite, 
-you can do so with:
 
-   rake test_sqlserver TEST=base_test.rb
-   
-That'll run the base suite using the SQLServer-Ruby adapter.
 

data/Rakefile

@@ -3,39 +3,65 @@ require 'rake/testtask'
 require 'rake/rdoctask'
 
 
-namespace :sqlserver do
+def test_libs(mode='odbc')
+  ['lib',
+   'test',
+   "test/connections/native_sqlserver#{mode == 'adonet' ? '' : "_#{mode}"}",
+   "#{ENV['RAILS_SOURCE']}/activerecord/test"]
+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
+end
+
+
+task :test => ['test:odbc']
+
+
+namespace :test do
   
-  namespace :test do
+  ['odbc','adonet'].each do |mode|
     
-    ['odbc','adonet'].each do |mode|
-
-      Rake::TestTask.new(mode) do |t|
-        t.libs << "test"
-        t.libs << "test/connections/native_sqlserver#{mode == 'adonet' ? '' : "_#{mode}"}"
-        t.libs << "../../../rails/activerecord/test/"
-        t.test_files = (
-          Dir.glob("test/cases/**/*_test_sqlserver.rb").sort + 
-          Dir.glob("../../../rails/activerecord/test/**/*_test.rb").sort )
-        t.verbose = true
-      end
-      
-    end
-
-    desc 'Test with unicode types enabled, uses ODBC mode.'
-    task :unicode_types do
-      ENV['ENABLE_DEFAULT_UNICODE_TYPES'] = 'true'
-      test = Rake::Task['sqlserver:test:odbc']
-      test.invoke
+    Rake::TestTask.new(mode) do |t|
+      t.libs = test_libs(mode)
+      t.test_files = test_files
+      t.verbose = true
     end
     
   end
+
+  desc 'Test without unicode types enabled, uses ODBC mode.'
+  task :non_unicode_types do
+    ENV['ENABLE_DEFAULT_UNICODE_TYPES'] = 'false'
+    test = Rake::Task['test:odbc']
+    test.invoke
+  end
   
 end
 
 
-desc 'Default runs tests for the adapters ODBC mode.'
-task :test do
-  test = Rake::Task['sqlserver:test:odbc']
-  test.invoke
+namespace :profile do
+  
+  ['odbc','adonet'].each do |mode|
+    namespace mode.to_sym do
+      
+      Dir.glob("test/profile/*_profile_case.rb").sort.each do |test_file|
+        
+        profile_case = File.basename(test_file).sub('_profile_case.rb','')
+        
+        Rake::TestTask.new(profile_case) do |t|
+          t.libs = test_libs(mode)
+          t.test_files = [test_file]
+          t.verbose = true
+        end
+        
+      end
+      
+    end
+  end
+  
 end
 
+

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -20,7 +20,7 @@ module ActiveRecord
         require 'System.Data'
         raise ArgumentError, 'Missing :database configuration.' unless config.has_key?(:database)
       when :ado
-        raise NotImplementedError, 'Please use version 2.3.1 of the adapter for ADO connections. Future versions may support ADO.NET.'
+        raise NotImplementedError, 'Please use version 2.3.1 of the adapter for ADO connections. Future versions support ADO.NET.'
         raise ArgumentError, 'Missing :database configuration.' unless config.has_key?(:database)
       else
         raise ArgumentError, "Unknown connection mode in #{config.inspect}."
@@ -45,7 +45,7 @@ module ActiveRecord
     class SQLServerColumn < Column
             
       def initialize(name, default, sql_type = nil, null = true, sqlserver_options = {})
-        @sqlserver_options = sqlserver_options
+        @sqlserver_options = sqlserver_options.symbolize_keys
         super(name, default, sql_type, null)
       end
       
@@ -88,12 +88,15 @@ module ActiveRecord
       end
       
       def is_special?
-        # TODO: Not sure if these should be added: varbinary(max), nchar, nvarchar(max)
-        sql_type =~ /^text|ntext|image$/
+        @sql_type =~ /^text|ntext|image$/
       end
       
       def is_utf8?
-        sql_type =~ /nvarchar|ntext|nchar/i
+        @sql_type =~ /nvarchar|ntext|nchar/i
+      end
+      
+      def default_function
+        @sqlserver_options[:default_function]
       end
       
       def table_name
@@ -170,10 +173,11 @@ module ActiveRecord
     class SQLServerAdapter < AbstractAdapter
       
       ADAPTER_NAME                = 'SQLServer'.freeze
-      VERSION                     = '2.3.8'.freeze
+      VERSION                     = '2.3.9'.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
+      LIMITABLE_TYPES             = ['string','integer','float','char','nchar','varchar','nvarchar'].to_set.freeze
+      QUOTED_TRUE, QUOTED_FALSE   = '1', '0'
       LOST_CONNECTION_EXCEPTIONS  = {
         :odbc   => ['ODBC::Error'],
         :adonet => ['TypeError','System::Data::SqlClient::SqlException']
@@ -183,6 +187,8 @@ module ActiveRecord
         :adonet => [/current state is closed/, /network-related/]
       }
       
+      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
       
@@ -197,10 +203,13 @@ module ActiveRecord
       def initialize(logger,config)
         @connection_options = config
         connect
-        super(raw_connection, logger)
+        super(@connection, logger)
+        @database_version = info_schema_query { select_value('SELECT @@version') }
+        @database_year = DATABASE_VERSION_REGEXP.match(@database_version)[1].to_i rescue 0
+        initialize_native_database_types
         initialize_sqlserver_caches
         use_database
-        unless SUPPORTED_VERSIONS.include?(database_year)
+        unless SUPPORTED_VERSIONS.include?(@database_year)
           raise NotImplementedError, "Currently, only #{SUPPORTED_VERSIONS.to_sentence} are supported."
         end
       end
@@ -223,28 +232,20 @@ module ActiveRecord
         true
       end
       
-      def database_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
+        @database_year == 2000
       end
       
       def sqlserver_2005?
-        database_year == 2005
+        @database_year == 2005
       end
       
       def sqlserver_2008?
-        database_year == 2008
+        @database_year == 2008
       end
       
       def version
@@ -252,7 +253,7 @@ module ActiveRecord
       end
       
       def inspect
-        "#<#{self.class} version: #{version}, year: #{database_year}, connection_options: #{@connection_options.inspect}>"
+        "#<#{self.class} version: #{version}, year: #{@database_year}, connection_options: #{@connection_options.inspect}>"
       end
       
       def auto_connect
@@ -306,21 +307,21 @@ module ActiveRecord
         string.to_s.gsub(/\'/, "''")
       end
       
-      def quote_column_name(column_name)
-        column_name.to_s.split('.').map{ |name| name =~ /^\[.*\]$/ ? name : "[#{name}]" }.join('.')
+      def quote_column_name(name)
+        @sqlserver_quoted_column_and_table_names[name] ||= 
+          name.to_s.split('.').map{ |n| n =~ /^\[.*\]$/ ? n : "[#{n}]" }.join('.')
       end
       
-      def quote_table_name(table_name)
-        return table_name if table_name =~ /^\[.*\]$/
-        quote_column_name(table_name)
+      def quote_table_name(name)
+        quote_column_name(name)
       end
       
       def quoted_true
-        '1'
+        QUOTED_TRUE
       end
 
       def quoted_false
-        '0'
+        QUOTED_FALSE
       end
       
       def quoted_date(value)
@@ -360,11 +361,11 @@ module ActiveRecord
       end
 
       def disconnect!
-        case connection_mode
+        case @connection_options[:mode]
         when :odbc
-          raw_connection.disconnect rescue nil
+          @connection.disconnect rescue nil
         else :adonet
-          raw_connection.close rescue nil
+          @connection.close rescue nil
         end
       end
       
@@ -394,8 +395,22 @@ module ActiveRecord
         end if block_given?
       end
       
+      def select_one(sql, name = nil)
+        result = raw_select sql, name, :fetch => :one
+        (result && result.first.present?) ? result.first : nil
+      end
+      
+      def select_one_with_query_cache(*args)
+        if @query_cache_enabled
+          cache_sql(args.first) { select_one_without_query_cache(*args) }
+        else
+          select_one_without_query_cache(*args)
+        end
+      end
+      alias_method_chain :select_one, :query_cache
+      
       def select_rows(sql, name = nil)
-        raw_select(sql,name).first.last
+        raw_select sql, name, :fetch => :rows
       end
       
       def execute(sql, name = nil, skip_logging = false)
@@ -409,13 +424,21 @@ module ActiveRecord
       def execute_procedure(proc_name, *variables)
         vars = variables.map{ |v| quote(v) }.join(', ')
         sql = "EXEC #{proc_name} #{vars}".strip
-        select(sql,'Execute Procedure',true).inject([]) do |results,row|
-          if row.kind_of?(Array)
-            results << row.inject([]) { |rs,r| rs << r.with_indifferent_access }
-          else
-            results << row.with_indifferent_access
+        results = []
+        log(sql,'Execute Procedure') do
+          raw_connection_run(sql) do |handle|
+            get_rows = lambda {
+              rows = handle_to_names_and_values handle, :fetch => :all
+              rows.each_with_index { |r,i| rows[i] = r.with_indifferent_access }
+              results << rows
+            }
+            get_rows.call
+            while handle_more_results?(handle)
+              get_rows.call
+            end
           end
         end
+        results.many? ? results : results.first
       end
       
       def use_database(database=nil)
@@ -537,30 +560,18 @@ module ActiveRecord
         "WHERE #{quoted_primary_key} IN (SELECT #{limit} #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
       end
       
+      def newid_function
+        select_value "SELECT NEWID()"
+      end
+      
+      def newsequentialid_function
+        select_value "SELECT NEWSEQUENTIALID()"
+      end
+      
       # SCHEMA STATEMENTS ========================================#
       
       def native_database_types
-        {
-          :primary_key  => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
-          :string       => { :name => native_string_database_type, :limit => 255  },
-          :text         => { :name => native_text_database_type },
-          :integer      => { :name => "int", :limit => 4 },
-          :float        => { :name => "float", :limit => 8 },
-          :decimal      => { :name => "decimal" },
-          :datetime     => { :name => "datetime" },
-          :timestamp    => { :name => "datetime" },
-          :time         => { :name => native_time_database_type },
-          :date         => { :name => native_date_database_type },
-          :binary       => { :name => native_binary_database_type },
-          :boolean      => { :name => "bit"},
-          # These are custom types that may move somewhere else for good schema_dumper.rb hacking to output them.
-          :char         => { :name => 'char' },
-          :varchar_max  => { :name => 'varchar(max)' },
-          :nchar        => { :name => "nchar" },
-          :nvarchar     => { :name => "nvarchar", :limit => 255 },
-          :nvarchar_max => { :name => "nvarchar(max)" },
-          :ntext        => { :name => "ntext" }
-        }
+        ActiveRecord::ConnectionAdapters::SQLServerAdapter::NATIVE_DATABASE_TYPES
       end
       
       def table_alias_length
@@ -583,8 +594,9 @@ module ActiveRecord
         @sqlserver_view_information_cache[table_name] ||= begin
           view_info = info_schema_query { select_one("SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{table_name}'") }
           if view_info
-            if view_info['VIEW_DEFINITION'].blank? || view_info['VIEW_DEFINITION'].length == 4000
-              view_info['VIEW_DEFINITION'] = info_schema_query { select_values("EXEC sp_helptext #{table_name}").join }
+            view_info = view_info.with_indifferent_access
+            if view_info[:VIEW_DEFINITION].blank? || view_info[:VIEW_DEFINITION].length == 4000
+              view_info[:VIEW_DEFINITION] = info_schema_query { select_values("EXEC sp_helptext #{table_name}").join }
             end
           end
           view_info
@@ -603,12 +615,13 @@ module ActiveRecord
       def indexes(table_name, name = nil)
         unquoted_table_name = unqualify_table_name(table_name)
         select("EXEC sp_helpindex #{quote_table_name(unquoted_table_name)}",name).inject([]) do |indexes,index|
-          if index['index_description'] =~ /primary key/
+          index = index.with_indifferent_access
+          if index[:index_description] =~ /primary key/
             indexes
           else
-            name    = index['index_name']
-            unique  = index['index_description'] =~ /unique/
-            columns = index['index_keys'].split(',').map do |column|
+            name    = index[:index_name]
+            unique  = index[:index_description] =~ /unique/
+            columns = index[:index_keys].split(',').map do |column|
               column.strip!
               column.gsub! '(-)', '' if column.ends_with?('(-)')
               column
@@ -647,6 +660,7 @@ module ActiveRecord
       end
       
       def remove_column(table_name, *column_names)
+        raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
         column_names.flatten.each do |column_name|
           remove_check_constraints(table_name, column_name)
           remove_default_constraint(table_name, column_name)
@@ -798,9 +812,23 @@ module ActiveRecord
       
       def connect
         config = @connection_options
-        @connection = case connection_mode
+        @connection = case @connection_options[:mode]
                       when :odbc
-                        ODBC.connect config[:dsn], config[:username], config[:password]
+                        if config[:dsn].include?(';')
+                          driver = ODBC::Driver.new.tap do |d|
+                            d.name = config[:dsn_name] || 'Driver1'
+                            driver.attrs = dsn.split(';').map{ |atr| atr.split('=') }.reject{ |kv| kv.size != 2 }.inject({}){ |h,kv| k,v = kv ; h[k] = v ; h }
+                          end
+                          ODBC::Database.new.drvconnect(driver)
+                        else
+                          ODBC.connect config[:dsn], config[:username], config[:password]
+                        end.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|
@@ -822,17 +850,13 @@ module ActiveRecord
         raise unless @auto_connecting
       end
       
-      def connection_mode
-        @connection_options[:mode]
-      end
-      
       def lost_connection_exceptions
-        exceptions = LOST_CONNECTION_EXCEPTIONS[connection_mode]
+        exceptions = LOST_CONNECTION_EXCEPTIONS[@connection_options[:mode]]
         @lost_connection_exceptions ||= exceptions ? exceptions.map(&:constantize) : []
       end
       
       def lost_connection_messages
-        LOST_CONNECTION_MESSAGES[connection_mode]
+        LOST_CONNECTION_MESSAGES[@connection_options[:mode]]
       end
       
       def with_auto_reconnect
@@ -864,26 +888,26 @@ module ActiveRecord
       
       def raw_connection_run(sql)
         with_auto_reconnect do
-          case connection_mode
+          case @connection_options[:mode]
           when :odbc
-            block_given? ? raw_connection.run_block(sql) { |handle| yield(handle) } : raw_connection.run(sql)
+            block_given? ? @connection.run_block(sql) { |handle| yield(handle) } : @connection.run(sql)
           else :adonet
-            raw_connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_reader
+            @connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_reader
           end
         end
       end
       
       def raw_connection_do(sql)
-        case connection_mode
+        case @connection_options[:mode]
         when :odbc
-          raw_connection.do(sql)
+          @connection.do(sql)
         else :adonet
-          raw_connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_non_query
+          @connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_non_query
         end
       end
       
       def finish_statement_handle(handle)
-        case connection_mode
+        case @connection_options[:mode]
         when :odbc
           handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
         when :adonet
@@ -895,24 +919,8 @@ module ActiveRecord
       
       # DATABASE STATEMENTS ======================================
       
-      def select(sql, name = nil, ignore_special_columns = false)
-        repair_special_columns(sql) unless ignore_special_columns
-        fields_and_row_sets = raw_select(sql,name)
-        final_result_set = fields_and_row_sets.inject([]) do |rs,fields_and_rows|
-          fields, rows = fields_and_rows
-          rs << zip_fields_and_rows(fields,rows)
-        end
-        final_result_set.many? ? final_result_set : final_result_set.first
-      end
-      
-      def zip_fields_and_rows(fields, rows)
-        rows.inject([]) do |results,row|
-          row_hash = {}
-          fields.each_with_index do |f, i|
-            row_hash[f] = row[i]
-          end
-          results << row_hash
-        end
+      def select(sql, name = nil)
+        raw_select sql, name, :fetch => :all
       end
       
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
@@ -934,30 +942,19 @@ module ActiveRecord
         end
       end
       
-      def raw_select(sql, name = nil)
-        fields_and_row_sets = []
+      def raw_select(sql, name=nil, options={})
         log(sql,name) do
           begin
             handle = raw_connection_run(sql)
-            loop do
-              fields_and_rows = case connection_mode
-                                when :odbc
-                                  handle_to_fields_and_rows_odbc(handle)
-                                when :adonet
-                                  handle_to_fields_and_rows_adonet(handle)
-                                end
-              fields_and_row_sets << fields_and_rows
-              break unless handle_more_results?(handle)
-            end
+            handle_to_names_and_values(handle, options)
           ensure
             finish_statement_handle(handle)
           end
         end
-        fields_and_row_sets
       end
       
       def handle_more_results?(handle)
-        case connection_mode
+        case @connection_options[:mode]
         when :odbc
           handle.more_results
         when :adonet
@@ -965,50 +962,109 @@ module ActiveRecord
         end
       end
       
-      def handle_to_fields_and_rows_odbc(handle)
-        fields = handle.columns(true).map { |c| c.name }
-        results = handle.inject([]) do |rows,row|
-          rows << row.inject([]) { |values,value| values << value }
+      def handle_to_names_and_values(handle, options={})
+        case @connection_options[:mode]
+        when :odbc
+          handle_to_names_and_values_odbc(handle, options)
+        when :adonet
+          handle_to_names_and_values_adonet(handle, options)
         end
-        rows = results.inject([]) do |rows,row|
-          row.each_with_index do |value, i|
-            if value.is_a? ODBC::TimeStamp
-              row[i] = value.to_sqlserver_string
+      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
+          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
+          end
+        when :rows
+          rows = handle.fetch_all || []
+          return rows if @connection_supports_native_types
+          rows.each do |row|
+            i = 0
+            while i < row.size
+              v = row[i]
+              row[i] = v.to_sqlserver_string if v.respond_to?(:to_sqlserver_string)
+              i += 1
             end
           end
-          rows << row
+          rows
         end
-        [fields,rows]
       end
-      
-      def handle_to_fields_and_rows_adonet(handle)
+
+      def handle_to_names_and_values_adonet(handle, options={})
         if handle.has_rows
-          fields = []
+          names = []
           rows = []
-          fields_named = false
+          fields_named = options[:fetch] == :rows
+          one_row_only = options[:fetch] == :one
           while handle.read
             row = []
             handle.visible_field_count.times do |row_index|
               value = handle.get_value(row_index)
-              value = if value.is_a? System::String
+              value = case value
+                      when System::String
                         value.to_s
-                      elsif value.is_a? System::DBNull
+                      when System::DBNull
                         nil
-                      elsif value.is_a? System::DateTime
-                        value.to_string("yyyy-MM-dd HH:MM:ss.fff").to_s
+                      when System::DateTime
+                        value.to_string("yyyy-MM-dd HH:mm:ss.fff").to_s
+                      when @@array_of_bytes ||= System::Array[System::Byte]
+                        String.new(value)
                       else
                         value
                       end
               row << value
-              fields << handle.get_name(row_index).to_s unless fields_named
+              names << handle.get_name(row_index).to_s unless fields_named
+              break if one_row_only
             end
             rows << row
             fields_named = true
           end
         else
-          fields, rows = [], []
+          rows = []
+        end
+        if options[:fetch] != :rows
+          names_and_values = []
+          rows.each do |row|
+            h = {}
+            i = 0
+            while i < row.size
+              h[names[i]] = row[i]
+              i += 1
+            end
+            names_and_values << h
+          end
+          names_and_values
+        else
+          rows
         end
-        [fields,rows]
       end
       
       def add_limit_offset_for_association_limiting!(sql, options)
@@ -1129,7 +1185,7 @@ module ActiveRecord
       end
       
       def views_real_column_name(table_name,column_name)
-        view_definition = view_information(table_name)['VIEW_DEFINITION']
+        view_definition = view_information(table_name)[:VIEW_DEFINITION]
         match_data = view_definition.match(/([\w-]*)\s+as\s+#{column_name}/im)
         match_data ? match_data[1] : column_name
       end
@@ -1158,6 +1214,32 @@ module ActiveRecord
         @sqlserver_columns_cache = {} if reset_columns
         @sqlserver_views_cache = nil
         @sqlserver_view_information_cache = {}
+        @sqlserver_quoted_column_and_table_names = {}
+      end
+      
+      def initialize_native_database_types
+        return if defined?(ActiveRecord::ConnectionAdapters::SQLServerAdapter::NATIVE_DATABASE_TYPES)
+        ActiveRecord::ConnectionAdapters::SQLServerAdapter.const_set(:NATIVE_DATABASE_TYPES,{
+          :primary_key  => "int NOT NULL IDENTITY(1,1) PRIMARY KEY",
+          :string       => { :name => native_string_database_type, :limit => 255  },
+          :text         => { :name => native_text_database_type },
+          :integer      => { :name => "int", :limit => 4 },
+          :float        => { :name => "float", :limit => 8 },
+          :decimal      => { :name => "decimal" },
+          :datetime     => { :name => "datetime" },
+          :timestamp    => { :name => "datetime" },
+          :time         => { :name => native_time_database_type },
+          :date         => { :name => native_date_database_type },
+          :binary       => { :name => native_binary_database_type },
+          :boolean      => { :name => "bit"},
+          # These are custom types that may move somewhere else for good schema_dumper.rb hacking to output them.
+          :char         => { :name => 'char' },
+          :varchar_max  => { :name => 'varchar(max)' },
+          :nchar        => { :name => "nchar" },
+          :nvarchar     => { :name => "nvarchar", :limit => 255 },
+          :nvarchar_max => { :name => "nvarchar(max)" },
+          :ntext        => { :name => "ntext" }
+        })
       end
       
       def column_definitions(table_name)
@@ -1179,7 +1261,7 @@ module ActiveRecord
           CASE
             WHEN columns.IS_NULLABLE = 'YES' THEN 1
             ELSE NULL
-          end as is_nullable,
+          END as is_nullable,
           CASE
             WHEN COLUMNPROPERTY(OBJECT_ID(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME), columns.COLUMN_NAME, 'IsIdentity') = 0 THEN NULL
             ELSE 1
@@ -1188,9 +1270,9 @@ module ActiveRecord
           WHERE columns.TABLE_NAME = '#{table_name}'
           ORDER BY columns.ordinal_position
         }.gsub(/[ \t\r\n]+/,' ')
-        results = info_schema_query { select(sql,nil,true) }
+        results = info_schema_query { select(sql,nil) }
         results.collect do |ci|
-          ci.symbolize_keys!
+          ci = ci.symbolize_keys
           ci[:type] = case ci[:type]
                       when /^bit|image|text|ntext|datetime$/
                         ci[:type]
@@ -1210,6 +1292,9 @@ module ActiveRecord
           ci[:default_value] = case ci[:default_value]
                                when nil, '(null)', '(NULL)'
                                  nil
+                               when /\A\((\w+\(\))\)\Z/
+                                 ci[:default_function] = $1
+                                 nil
                                else
                                  match_data = ci[:default_value].match(/\A\(+N?'?(.*?)'?\)+\Z/m)
                                  match_data ? match_data[1] : nil

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

@@ -133,7 +133,7 @@ module ActiveRecord
           end
           
         end
-        
+                
       end
       
       

data/test/cases/adapter_test_sqlserver.rb

@@ -71,21 +71,6 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
         assert_contains @supported_version, @connection.database_year
       end
       
-      should 'return true to #sqlserver_2000?' do
-        @connection.stubs(:database_version).returns(@sqlserver_2000_string)
-        assert @connection.sqlserver_2000?
-      end
-      
-      should 'return true to #sqlserver_2005?' do
-        @connection.stubs(:database_version).returns(@sqlserver_2005_string)
-        assert @connection.sqlserver_2005?
-      end
-      
-      should 'return true to #sqlserver_2008?' do
-        @connection.stubs(:database_version).returns(@sqlserver_2008_string)
-        assert @connection.sqlserver_2008?
-      end
-      
     end
     
     context 'for #unqualify_table_name and #unqualify_db_name' do
@@ -303,13 +288,13 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
 
         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
 
@@ -320,14 +305,14 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
         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
         

data/test/cases/basics_test_sqlserver.rb

@@ -14,7 +14,9 @@ class BasicsTest < ActiveRecord::TestCase
   
   def test_coerced_test_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
   
   

data/test/cases/execute_procedure_test_sqlserver.rb

@@ -20,15 +20,6 @@ class ExecuteProcedureTestSqlserver < ActiveRecord::TestCase
     assert_equal 'TABLE', table_info[:TABLE_TYPE], "Table Info: #{table_info.inspect}"
   end
   
-  should 'quote bind vars correctly' do
-    assert_sql(/EXEC sp_tables '%sql_server%', NULL, NULL, NULL, 1/) do
-      @klass.execute_procedure :sp_tables, '%sql_server%', nil, nil, nil, true
-    end if sqlserver_2005? || sqlserver_2008?
-    assert_sql(/EXEC sp_tables '%sql_server%', NULL, NULL, NULL/) do
-      @klass.execute_procedure :sp_tables, '%sql_server%', nil, nil, nil
-    end if sqlserver_2000?
-  end
-  
   should 'allow multiple result sets to be returned' do
     results1, results2 = @klass.execute_procedure('sp_helpconstraint','accounts')
     assert_instance_of Array, results1

data/test/cases/migration_test_sqlserver.rb

@@ -84,40 +84,3 @@ class MigrationTest < ActiveRecord::TestCase
   
 end
 
-class ChangeTableMigrationsTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [:test_string_creates_string_column]
-
-  include SqlserverCoercedTest
-  
-  def setup
-    @connection = Person.connection
-    @connection.create_table :delete_me, :force => true do |t|
-    end
-  end
-
-  def teardown
-    @connection.drop_table :delete_me rescue nil
-  end
-  
-  def test_coerced_string_creates_string_column
-    with_sqlserver_change_table do |t|
-      @connection.expects(:add_column).with(:delete_me, :foo, sqlserver_string_column, {})
-      @connection.expects(:add_column).with(:delete_me, :bar, sqlserver_string_column, {})
-      t.string :foo, :bar
-    end
-  end
-  
-  protected
-
-  def with_sqlserver_change_table
-    @connection.change_table :delete_me do |t|
-      yield t
-    end
-  end
-  
-  def sqlserver_string_column
-    "#{@connection.native_string_database_type}(255)"
-  end
-  
-end

data/test/cases/specific_schema_test_sqlserver.rb

@@ -1,7 +1,15 @@
 require 'cases/sqlserver_helper'
 
 class StringDefault < ActiveRecord::Base; end;
-class SqlServerEdgeSchema < ActiveRecord::Base; end;
+class SqlServerEdgeSchema < ActiveRecord::Base
+  attr_accessor :new_id_setting
+  before_create :set_new_id
+  protected
+  def set_new_id
+    self[:guid_newid] ||= connection.newid_function if new_id_setting
+    true
+  end
+end
 
 class SpecificSchemaTestSqlserver < ActiveRecord::TestCase
   
@@ -91,7 +99,47 @@ class SpecificSchemaTestSqlserver < ActiveRecord::TestCase
       
     end
     
+    context 'with uniqueidentifier column' do
+
+      setup do
+        @newid = ActiveRecord::Base.connection.newid_function
+        assert_guid @newid
+      end
+
+      should 'allow a simple insert and read of a column without a default function' do
+        obj = @edge_class.create! :guid => @newid
+        assert_equal @newid, @edge_class.find(obj.id).guid
+      end
+      
+      should 'record the default function name in the column definition but still show a nil real default, will use one day for insert/update' do
+        newid_column = @edge_class.columns_hash['guid_newid']
+        assert newid_column.default_function.present?
+        assert_nil newid_column.default
+        assert_equal 'newid()', newid_column.default_function
+        unless ActiveRecord::Base.connection.sqlserver_2000?
+          newseqid_column = @edge_class.columns_hash['guid_newseqid']
+          assert newseqid_column.default_function.present?
+          assert_nil newseqid_column.default
+          assert_equal 'newsequentialid()', newseqid_column.default_function
+        end
+      end
+      
+      should 'use model callback to set get a new guid' do
+        obj = @edge_class.new
+        obj.new_id_setting = true
+        obj.save!
+        assert_guid obj.guid_newid
+      end
+
+    end
+    
   end
   
   
+  protected
+  
+  def assert_guid(guid)
+    assert_match %r|\w{8}-\w{4}-\w{4}-\w{4}-\w{12}|, guid
+  end
+  
 end

data/test/cases/sqlserver_helper.rb

@@ -1,20 +1,26 @@
+
+SQLSERVER_TEST_ROOT       = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+SQLSERVER_ASSETS_ROOT     = File.expand_path(File.join(SQLSERVER_TEST_ROOT,'assets'))
+SQLSERVER_FIXTURES_ROOT   = File.expand_path(File.join(SQLSERVER_TEST_ROOT,'fixtures'))
+SQLSERVER_MIGRATIONS_ROOT = File.expand_path(File.join(SQLSERVER_TEST_ROOT,'migrations'))
+SQLSERVER_SCHEMA_ROOT     = File.expand_path(File.join(SQLSERVER_TEST_ROOT,'schema'))
+ACTIVERECORD_TEST_ROOT    = File.expand_path(File.join(ENV['RAILS_SOURCE'],'activerecord','test'))
+
 require 'rubygems'
+require 'bundler'
+Bundler.setup
 require 'shoulda'
 require 'mocha'
+begin ; require 'ruby-debug' ; rescue LoadError ; end
 [ File.expand_path(File.join(File.dirname(__FILE__),'..','..','test')),
   File.expand_path(File.join(File.dirname(__FILE__),'..','..','test','connections','native_sqlserver_odbc')),
-  File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','..','rails','activerecord','test'))
+  File.expand_path(File.join(ENV['RAILS_SOURCE'],'activerecord','test'))
 ].each{ |lib| $:.unshift(lib) unless $:.include?(lib) } if ENV['TM_DIRECTORY']
 require 'cases/helper'
 require 'models/topic'
 require 'active_record/version'
 
-SQLSERVER_TEST_ROOT       = File.expand_path(File.join(File.dirname(__FILE__),'..'))
-SQLSERVER_ASSETS_ROOT     = SQLSERVER_TEST_ROOT + "/assets"
-SQLSERVER_FIXTURES_ROOT   = SQLSERVER_TEST_ROOT + "/fixtures"
-SQLSERVER_MIGRATIONS_ROOT = SQLSERVER_TEST_ROOT + "/migrations"
-SQLSERVER_SCHEMA_ROOT     = SQLSERVER_TEST_ROOT + "/schema"
-ACTIVERECORD_TEST_ROOT    = File.expand_path(SQLSERVER_TEST_ROOT + "/../../../../rails/activerecord/test/")
+GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly?)
 
 ActiveRecord::Migration.verbose = false
 
@@ -63,7 +69,7 @@ end
 
 # Set weather to test unicode string defaults or not. Used from rake task.
 
-if ENV['ENABLE_DEFAULT_UNICODE_TYPES'] == 'true'
+if ENV['ENABLE_DEFAULT_UNICODE_TYPES'] != 'false'
   puts "With enabled unicode string types"
   ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types = true
 end
@@ -87,10 +93,10 @@ ActiveRecord::Base.connection.class.class_eval do
 end
 
 ActiveRecord::ConnectionAdapters::SQLServerAdapter.class_eval do
-  def raw_select_with_query_record(sql, name = nil)
+  def raw_select_with_query_record(sql, name=nil, options={})
     $queries_executed ||= []
     $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    raw_select_without_query_record(sql,name)
+    raw_select_without_query_record(sql,name,options)
   end
   alias_method_chain :raw_select, :query_record
 end
@@ -98,6 +104,7 @@ end
 module ActiveRecord 
   class TestCase < ActiveSupport::TestCase
     class << self
+      def connection_mode_odbc? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :odbc ; end
       def sqlserver_2000? ; ActiveRecord::Base.connection.sqlserver_2000? ; end
       def sqlserver_2005? ; ActiveRecord::Base.connection.sqlserver_2005? ; end
       def sqlserver_2008? ; ActiveRecord::Base.connection.sqlserver_2008? ; end

data/test/schema/sqlserver_specific_schema.rb

@@ -67,7 +67,10 @@ ActiveRecord::Schema.define do
     t.string :description
     t.column :bigint, :bigint
     t.column :tinyint, :tinyint
+    t.column :guid, :uniqueidentifier
   end
+  execute %|ALTER TABLE [sql_server_edge_schemas] ADD [guid_newid] uniqueidentifier DEFAULT NEWID();|
+  execute %|ALTER TABLE [sql_server_edge_schemas] ADD [guid_newseqid] uniqueidentifier DEFAULT NEWSEQUENTIALID();| unless ActiveRecord::Base.connection.sqlserver_2000?
   
   execute "IF EXISTS (SELECT TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = 'customers_view') DROP VIEW customers_view"
   execute <<-CUSTOMERSVIEW

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
+  hash: 17
   prerelease: false
   segments: 
   - 2
   - 3
-  - 8
-  version: 2.3.8
+  - 9
+  version: 2.3.9
 platform: ruby
 authors: 
 - Ken Collins
@@ -18,10 +19,24 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-07 00:00:00 -04:00
+date: 2010-09-15 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        version: "2.3"
+  type: :runtime
+  version_requirements: *id001
 description: SQL Server 2000, 2005 and 2008 Adapter For Rails.
 email: ken@metaskills.net
 executables: []
@@ -36,13 +51,37 @@ files:
 - Rakefile
 - README.rdoc
 - RUNNING_UNIT_TESTS
-- autotest/discover.rb
-- autotest/railssqlserver.rb
-- autotest/sqlserver.rb
 - lib/activerecord-sqlserver-adapter.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/odbc.rb
+- test/cases/aaaa_create_tables_test_sqlserver.rb
+- test/cases/adapter_test_sqlserver.rb
+- test/cases/attribute_methods_test_sqlserver.rb
+- test/cases/basics_test_sqlserver.rb
+- test/cases/calculations_test_sqlserver.rb
+- test/cases/column_test_sqlserver.rb
+- test/cases/connection_test_sqlserver.rb
+- test/cases/eager_association_test_sqlserver.rb
+- test/cases/execute_procedure_test_sqlserver.rb
+- test/cases/inheritance_test_sqlserver.rb
+- test/cases/method_scoping_test_sqlserver.rb
+- test/cases/migration_test_sqlserver.rb
+- test/cases/named_scope_test_sqlserver.rb
+- test/cases/offset_and_limit_test_sqlserver.rb
+- test/cases/pessimistic_locking_test_sqlserver.rb
+- test/cases/query_cache_test_sqlserver.rb
+- test/cases/schema_dumper_test_sqlserver.rb
+- test/cases/specific_schema_test_sqlserver.rb
+- test/cases/sqlserver_helper.rb
+- test/cases/table_name_test_sqlserver.rb
+- test/cases/transaction_test_sqlserver.rb
+- test/cases/unicode_test_sqlserver.rb
+- test/cases/validations_test_sqlserver.rb
+- test/connections/native_sqlserver/connection.rb
+- test/connections/native_sqlserver_odbc/connection.rb
+- test/migrations/transaction_table/1_table_will_never_be_created.rb
+- test/schema/sqlserver_specific_schema.rb
 has_rdoc: true
 homepage: http://github.com/rails-sqlserver
 licenses: []
@@ -56,23 +95,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: SQL Server 2000, 2005 and 2008 Adapter For Rails.

data/autotest/discover.rb

@@ -1,4 +0,0 @@
-
-Autotest.add_discovery do
-  ARGV.first || 'railssqlserver'
-end

data/autotest/railssqlserver.rb

@@ -1,16 +0,0 @@
-require 'autotest/sqlserver'
-
-class Autotest::Railssqlserver < Autotest::Sqlserver
-
-  def initialize
-    super
-    self.libs << "#{File::PATH_SEPARATOR}../../../rails/activerecord/test/"
-    self.extra_files = ['../../../rails/activerecord/test/']
-    self.add_mapping %r%../../../rails/activerecord/test/.*/.*_test.rb$% do |filename, _|
-      filename
-    end
-  end
-  
-
-end
-

data/autotest/sqlserver.rb

@@ -1,54 +0,0 @@
-require 'autotest'
-require 'active_support'
-
-class Autotest::Sqlserver < Autotest
-
-  def initialize
-    super
-    
-    odbc_mode = true
-    
-    clear_mappings
-    
-    self.libs = [
-      "lib",
-      "test",
-      "test/connections/native_sqlserver#{odbc_mode ? '_odbc' : ''}",
-      "../../../rails/activerecord/test/"
-    ].join(File::PATH_SEPARATOR)
-    
-    @test_sqlserver_file_match = %r%^test/cases/.*_test_sqlserver\.rb$%
-    
-    add_exception %r%^\./(?:autotest)%
-    add_exception %r%^\./(.*LICENSE|debug.log|README.*|CHANGELOG.*)$%i
-    
-    # Any *_test_sqlserver file saved runs that file
-    self.add_mapping @test_sqlserver_file_match do |filename, matchs|
-      filename
-    end
-    
-    # If any the adapter changes
-    # the test directory, ofcourse having _test.rb at the end, will run that test. 
-    self.add_mapping(%r%^lib/(.*)\.rb$%) do |filename, matchs|
-      files_matching @test_sqlserver_file_match
-    end
-    
-    # If any core file like the test helper, connections, fixtures, migratinos,
-    # and other support files, then run all matching *_test_sqlserver files.
-    add_mapping %r%^test/(cases/(sqlserver_helper)\.rb|connections|fixtures|migrations|schema/.*)% do
-      files_matching @test_sqlserver_file_match
-    end
-    
-  end
-  
-  # Have to use a custom reorder method since the normal :alpha for Autotest would put the 
-  # files with ../ in the path before others.
-  def reorder(files_to_test)
-    ar_tests, sqlsvr_tests = files_to_test.partition { |k,v| k.starts_with?('../../../') }
-    ar_tests.sort! { |a,b| a[0] <=> b[0] }
-    sqlsvr_tests.sort! { |a,b| a[0] <=> b[0] }
-    sqlsvr_tests + ar_tests
-  end
-  
-end
-