activerecord-sqlserver-adapter 3.1.0.rc2 → 3.1.0.rc5

data/CHANGELOG

@@ -1,6 +1,19 @@
 
 * 3.1.0 *
 
+* Quote most time objects to use ISO8601 format to be multi-language dateformat compatible. The [datetime] data type is
+  automatically limited to milliseconds while [time] & [datetimeoffset] have full support. Even included a Date/Time 
+  ActiveSupport formatter that is used per the language settings of the connection.
+
+* Include a visit_Arel_Nodes_UpdateStatement method in our Arel visitor to add a limit/top for update
+  that has order and no limit/top. https://github.com/rails/rails/commit/787194ee43ab1fb0a7dc8bfbbfbd5079b047d833
+  
+* Allow drop_database to be called even when DB does not exist.
+
+* Remove totally broken ADONET connection mode. Want it back, submit a patch.
+
+* Schema reflection now finds primary key for all occasions. Fixed #60 [Boško Ivanišević]
+
 * Allow complex order objects to not be molested by our visitor overrides. Fixes #99
 
 * Default unicode datatypes!

data/README.rdoc

@@ -1,15 +1,16 @@
 
 == SQL Server 2005/2008 & Azure Adapter For ActiveRecord
 
-The SQL Server adapter for ActiveRecord.
+The SQL Server adapter for ActiveRecord. If you need the adapter for SQL Server 2000, you are still in the right spot. Just install the latest 2.3.x version of the adapter. Note, we follow a rational versioning policy that tracks ActiveRecord. That means that our 2.3.x version of the adapter is only for the latest 2.3 version of Rails.
 
 
 == What's New
 
 * Rails 3.1 prepared statement support leverages cached query plans.
+* We now support your native language date/time formats automatically!
 * Default unicode datatypes! Disable with #enable_default_unicode_types to false.
 * New #lowercase_schema_reflection configuration option for legacy DBs.
-* New dblib connection mode using TinyTds!
+* New dblib connection mode using TinyTDS! Default mode too!
 
 
 ==== Testing Rake Tasks Support
@@ -118,39 +119,22 @@ By default the adapter will auto connect to lost DB connections. For every query
 
 == 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.3.x will work on any 2.3.x version of ActiveRecord. Version 3.x will track ActiveRecord 3. This convention will be used in both the Git tags as well as the gems versioning.
+The adapter follows a rational versioning policy that also tracks ActiveRecord's major and minor version. That means the latest 3.1.x version of the adapter will always work for the latest 3.1.x version of ActiveRecord.
 
 
 == Installation
 
-You will need Ruby ODBC. If you are using the adapter under 1.9, then you need at least ruby-odbc version 0.99992. ODBC is the preferred mode, however if you are using IronRuby you can use the ADONET connection mode which uses native System.Data connection. Other connection modes may be supported, possibly a straight FreeTDS layer. The sky is the limit for optional transports. If you are interested in helping, open a ticket and submit a patch. Or start a conversation on the Google Group.
+The adapter has no strict gem dependencies outside of ActiveRecord. You will have to pick a connection mode, the default is dblib which uses the TinyTDS gem. Just bundle the gem and the adapter will use it.
 
-  $ gem install activerecord-sqlserver-adapter
+  gem 'tiny_tds'
+  gem 'activerecord-sqlserver-adapter', '~> 3.1.0'
 
-Optionally configure your gem dependencies in your Gemfile.
-
-  gem 'activerecord-sqlserver-adapter', '3.x.xx'
-
-If you have any troubles installing the lower level libraries for the adapter, please consult the wiki pages for various platform installation guides. Tons of good info can be found and we ask that you contribute too!
+If you want to use ruby ODBC, please use at least version 0.99992 since that contains fixes for both native types as well as fixes for proper encoding support under 1.9. If you have any troubles installing the lower level libraries for the adapter, please consult the wiki pages for various platform installation guides. Tons of good info can be found and we ask that you contribute too!
 
 http://wiki.github.com/rails-sqlserver/activerecord-sqlserver-adapter/platform-installation
 
 
 
-== IronRuby ADONET Mode
-
-A few details on this implementation. All that is needed in your database.yml configuration file is "mode: adonet" vs "odbc" and if you are running IronRuby, the connection will be native. You can also specify an "integrated_security: true" option in your configuration, remember to remove the username/password options too. To use this adapter, you will not need need ANY DBI middle layer or special extension gems to the adapter. 
-
-This adapter is opinionated in regards to IronRuby on types going in and out of the DB. For example strings will be String, not System::String and DateTime vs System::Datetime. There are many more examples but the rule of thumb is that the types will be simple types that correlate to a standard Ruby implementation. We enforce this basic rule because it is necessary to pass the tests and let the framework do its job. We recommend sticking to native Ruby types in your application code too.
-
-The adapter establishes a System::Data::SqlClient connection that has both MultipleActiveResultSets (MARS) and Pooling turned off. There are good reasons for this one because the connection would not work otherwise for all the code issued by ActiveRecord. Remember too that ActiveRecord has it's own connection pooling and these underlying features like MARS/Pooling work against the adapter code.
-
-Currently IronRuby is passing most of the ActiveRecord and Adapter tests. Here is a list of the ones remaining. Some are in the adapter's realm and some are in Marshaling area of IronRuby's core to fix. Feel like helping knock these out? Submit a patch to github issues.
-
-http://gist.github.com/381101
-
-
-
 == Contributing
 
 If you’d like to contribute a feature or bugfix, thanks! To make sure your fix/feature has a high chance of being added, please read the following guidelines. First, ask on the Google list, IRC, or post a ticket on github issues. Second, make sure there are tests! We will not accept any patch that is not tested. Please read the RUNNING_UNIT_TESTS file for the details of how to run the unit tests.
@@ -182,7 +166,7 @@ Up-to-date list of contributors: http://github.com/rails-sqlserver/activerecord-
 * jeremydurham (Jeremy Durham)
 
 === Donators
-http://pledgie.com/campaigns/11630
+http://pledgie.com/campaigns/15531
 
 == License
 

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -109,10 +109,6 @@ module ActiveRecord
                 end
               end
               results.many? ? results : results.first
-            when :adonet
-              results = []
-              results << select(sql, name).map { |r| r.with_indifferent_access }
-              results.many? ? results : results.first
             end
           end
         end
@@ -183,6 +179,8 @@ module ActiveRecord
               retry_count += 1
               remove_database_connections_and_rollback(database)
               retry
+            elsif err.message =~ /does not exist/i
+              nil
             else
               raise
             end
@@ -241,7 +239,7 @@ module ActiveRecord
             next if ar_column && column.sql_type == 'timestamp'
             v = value
             names_and_types << if ar_column
-                                 v = value.to_i if column.is_integer?
+                                 v = value.to_i if column.is_integer? && value.present?
                                  "@#{index} #{column.sql_type_for_statement}"
                                elsif column.acts_like?(:string)
                                  "@#{index} nvarchar(max)"
@@ -265,8 +263,6 @@ module ActiveRecord
             @connection.execute(sql).do
           when :odbc
             @connection.do(sql)
-          else :adonet
-            @connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_non_query
           end
         ensure
           @update_sql = false
@@ -292,8 +288,6 @@ module ActiveRecord
               @connection.execute(sql)
             when :odbc
               block_given? ? @connection.run_block(sql) { |handle| yield(handle) } : @connection.run(sql)
-            else :adonet
-              @connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_reader
             end
           end
         end
@@ -303,8 +297,6 @@ module ActiveRecord
           when :dblib
           when :odbc
             handle.more_results
-          when :adonet
-            handle.next_result
           end
         end
         
@@ -314,8 +306,6 @@ module ActiveRecord
             handle_to_names_and_values_dblib(handle, options)
           when :odbc
             handle_to_names_and_values_odbc(handle, options)
-          when :adonet
-            handle_to_names_and_values_adonet(handle, options)
           end
         end
         
@@ -344,62 +334,12 @@ module ActiveRecord
             end
           end
         end
-
-        def handle_to_names_and_values_adonet(handle, options={})
-          if handle.has_rows
-            names = []
-            rows = []
-            fields_named = options[:fetch] == :rows
-            while handle.read
-              row = []
-              handle.visible_field_count.times do |row_index|
-                value = handle.get_value(row_index)
-                value = case value
-                        when System::String
-                          value.to_s
-                        when System::DBNull
-                          nil
-                        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
-                names << handle.get_name(row_index).to_s unless fields_named
-              end
-              rows << row
-              fields_named = true
-            end
-          else
-            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
-        end
         
         def finish_statement_handle(handle)
           case @connection_options[:mode]
           when :dblib  
           when :odbc
             handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
-          when :adonet
-            handle.close if handle && handle.respond_to?(:close) && !handle.is_closed
-            handle.dispose if handle && handle.respond_to?(:dispose)
           end
           handle
         end

data/lib/active_record/connection_adapters/sqlserver/errors.rb

@@ -9,14 +9,12 @@ module ActiveRecord
         
         LOST_CONNECTION_EXCEPTIONS  = {
           :dblib  => ['TinyTds::Error'],
-          :odbc   => ['ODBC::Error'],
-          :adonet => ['TypeError','System::Data::SqlClient::SqlException']
+          :odbc   => ['ODBC::Error']
         }.freeze
         
         LOST_CONNECTION_MESSAGES    = {
           :dblib  => [/closed connection/, /dead or not enabled/, /server failed/i],
-          :odbc   => [/link failure/, /server failed/, /connection was already closed/, /invalid handle/i],
-          :adonet => [/current state is closed/, /network-related/]
+          :odbc   => [/link failure/, /server failed/, /connection was already closed/, /invalid handle/i]
         }.freeze
         
         

data/lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -8,13 +8,23 @@ module ActiveRecord
         def quote(value, column = nil)
           case value
           when String, ActiveSupport::Multibyte::Chars
-            if column && column.type == :binary
+            if column && column.type == :integer && value.blank?
+              nil
+            elsif column && column.type == :binary
               column.class.string_to_binary(value)
             elsif value.is_utf8? || (column && column.type == :string)
               "N'#{quote_string(value)}'"
             else
               super
             end
+          when Date, Time
+            if column && column.sql_type == 'datetime'
+              "'#{quoted_datetime(value)}'"
+            elsif column && (column.sql_type == 'datetimeoffset' || column.sql_type == 'time')
+              "'#{quoted_full_iso8601(value)}'"
+            else
+              super
+            end
           when nil
             column.respond_to?(:sql_type) && column.sql_type == 'timestamp' ? 'DEFAULT' : super
           else
@@ -51,14 +61,39 @@ module ActiveRecord
           QUOTED_FALSE
         end
 
+        def quoted_datetime(value)
+          if value.acts_like?(:time)
+            value.is_a?(Date) ? quoted_value_acts_like_time_filter(value).to_time.xmlschema.to(18) : quoted_value_acts_like_time_filter(value).iso8601(3).to(22)
+          else
+            quoted_date(value)
+          end
+        end
+        
+        def quoted_full_iso8601(value)
+          if value.acts_like?(:time)
+            value.is_a?(Date) ? quoted_value_acts_like_time_filter(value).to_time.xmlschema.to(18) : quoted_value_acts_like_time_filter(value).iso8601(7).to(22)
+          else
+            quoted_date(value)
+          end
+        end
+
         def quoted_date(value)
           if value.acts_like?(:time) && value.respond_to?(:usec)
             "#{super}.#{sprintf("%03d",value.usec/1000)}"
+          elsif value.acts_like?(:date)
+            value.to_s(:_sqlserver_dateformat)
           else
             super
           end
         end
         
+        protected
+        
+        def quoted_value_acts_like_time_filter(value)
+          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+          value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
+        end
+        
       end
     end
   end

data/lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -7,9 +7,9 @@ module ActiveRecord
           @native_database_types ||= initialize_native_database_types.freeze
         end
 
-        def tables(name = nil)
+        def tables(name = nil, table_type = 'BASE TABLE')
           info_schema_query do
-            select_values "SELECT #{lowercase_schema_reflection_sql('TABLE_NAME')} FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME <> 'dtproperties' AND TABLE_SCHEMA = schema_name()"
+            select_values "SELECT #{lowercase_schema_reflection_sql('TABLE_NAME')} FROM INFORMATION_SCHEMA.TABLES #{"WHERE TABLE_TYPE = '#{table_type}'" if table_type} ORDER BY TABLE_NAME"
           end
         end
 
@@ -19,8 +19,8 @@ module ActiveRecord
         end
 
         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|
+          data = select("EXEC sp_helpindex #{quote(table_name)}",name) rescue []
+          data.inject([]) do |indexes,index|
             index = index.with_indifferent_access
             if index[:index_description] =~ /primary key/
               indexes
@@ -39,16 +39,31 @@ module ActiveRecord
 
         def columns(table_name, name = nil)
           return [] if table_name.blank?
-          column_definitions(table_name).collect do |ci|
+          @sqlserver_columns_cache[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
         end
 
+        def create_table(table_name, options = {})
+          super
+          clear_cache!
+        end
+        
         def rename_table(table_name, new_name)
           do_execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
         end
+        
+        def drop_table(table_name, options = {})
+          super
+          clear_cache!
+        end
 
+        def add_column(table_name, column_name, type, options = {})
+          super
+          clear_cache!
+        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|
@@ -57,6 +72,7 @@ module ActiveRecord
             remove_indexes(table_name, column_name)
             do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
           end
+          clear_cache!
         end
 
         def change_column(table_name, column_name, type, options = {})
@@ -72,16 +88,19 @@ module ActiveRecord
             sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name,column_name)} DEFAULT #{quote(options[:default])} FOR #{quote_column_name(column_name)}"
           end
           sql_commands.each { |c| do_execute(c) }
+          clear_cache!
         end
 
         def change_column_default(table_name, column_name, default)
           remove_default_constraint(table_name, column_name)
           do_execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote(default)} FOR #{quote_column_name(column_name)}"
+          clear_cache!
         end
 
         def rename_column(table_name, column_name, new_column_name)
           detect_column_for!(table_name,column_name)
           do_execute "EXEC sp_rename '#{table_name}.#{column_name}', '#{new_column_name}', 'COLUMN'"
+          clear_cache!
         end
         
         def remove_index!(table_name, index_name)
@@ -117,8 +136,7 @@ module ActiveRecord
         # === SQLServer Specific ======================================== #
         
         def views(name = nil)
-          @sqlserver_views_cache ||= 
-            info_schema_query { select_values("SELECT #{lowercase_schema_reflection_sql('TABLE_NAME')} FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME NOT IN ('sysconstraints','syssegments')") }
+          @sqlserver_views_cache ||= tables(name,'VIEW')
         end
         
         
@@ -150,36 +168,41 @@ module ActiveRecord
             :ss_timestamp => { :name => 'timestamp' }
           }
         end
-        
+
         def column_definitions(table_name)
           db_name = unqualify_db_name(table_name)
           db_name_with_period = "#{db_name}." if db_name
           table_schema = unqualify_table_schema(table_name)
           table_name = unqualify_table_name(table_name)
           sql = %{
-            SELECT
+            SELECT DISTINCT 
             #{lowercase_schema_reflection_sql('columns.TABLE_NAME')} AS table_name,
             #{lowercase_schema_reflection_sql('columns.COLUMN_NAME')} AS name,
             columns.DATA_TYPE AS type,
             columns.COLUMN_DEFAULT AS default_value,
             columns.NUMERIC_SCALE AS numeric_scale,
             columns.NUMERIC_PRECISION AS numeric_precision,
+            columns.ordinal_position,
             CASE
               WHEN columns.DATA_TYPE IN ('nchar','nvarchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
               ELSE COL_LENGTH(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
-            END AS length,
+            END AS [length],
             CASE
               WHEN columns.IS_NULLABLE = 'YES' THEN 1
               ELSE NULL
-            END AS is_nullable,
-            CASE
-              WHEN COLUMNPROPERTY(OBJECT_ID(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME), columns.COLUMN_NAME, 'IsIdentity') = 0 THEN NULL
-              ELSE 1
-            END AS is_identity
+            END AS [is_nullable],
+            CASE 
+              WHEN CCU.COLUMN_NAME IS NOT NULL AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' THEN 1
+              WHEN COLUMNPROPERTY(OBJECT_ID(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME), columns.COLUMN_NAME, 'IsIdentity') = 1 THEN 1
+              ELSE NULL
+            END AS [is_identity]
             FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS columns
+            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC ON TC.TABLE_NAME = columns.TABLE_NAME AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' 
+            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS CCU ON TC.CONSTRAINT_NAME = CCU.CONSTRAINT_NAME AND CCU.COLUMN_NAME = columns.COLUMN_NAME
             WHERE columns.TABLE_NAME = @0
               AND columns.TABLE_SCHEMA = #{table_schema.blank? ? "schema_name()" : "@1"}
             ORDER BY columns.ordinal_position
+            
           }.gsub(/[ \t\r\n]+/,' ')
           binds = [['table_name', table_name]]
           binds << ['table_schema',table_schema] unless table_schema.blank?
@@ -213,6 +236,7 @@ module ActiveRecord
                                    match_data ? match_data[1] : nil
                                  end
             ci[:null] = ci[:is_nullable].to_i == 1 ; ci.delete(:is_nullable)
+            ci[:is_identity] = ci[:is_identity].to_i == 1
             ci
           end
         end
@@ -324,6 +348,7 @@ module ActiveRecord
         # === SQLServer Specific (Column/View Caches) =================== #
 
         def initialize_sqlserver_caches
+          @sqlserver_columns_cache = {}
           @sqlserver_views_cache = nil
           @sqlserver_view_information_cache = {}
           @sqlserver_quoted_column_and_table_names = {}
@@ -361,7 +386,7 @@ module ActiveRecord
         end
 
         def identity_column(table_name)
-          columns(table_name).detect(&:is_identity?)
+          columns(table_name).detect(&:primary) || columns(table_name).detect(&:is_identity?)
         end
 
       end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -21,15 +21,12 @@ module ActiveRecord
       mode = config[:mode].to_s.downcase.underscore.to_sym
       case mode
       when :dblib
-        require_library_or_gem 'tiny_tds'
+        require 'tiny_tds'
         warn("TinyTds v0.4.3 or higher required. Using #{TinyTds::VERSION}") unless TinyTds::Client.instance_methods.map(&:to_s).include?("active?")
       when :odbc
         raise ArgumentError, 'Missing :dsn configuration.' unless config.has_key?(:dsn)
-        require_library_or_gem 'odbc'
+        require 'odbc'
         require 'active_record/connection_adapters/sqlserver/core_ext/odbc'
-      when :adonet
-        require 'System.Data'
-        raise ArgumentError, 'Missing :database configuration.' unless config.has_key?(:database)
       else
         raise ArgumentError, "Unknown connection mode in #{config.inspect}."
       end
@@ -55,6 +52,7 @@ module ActiveRecord
       def initialize(name, default, sql_type = nil, null = true, sqlserver_options = {})
         @sqlserver_options = sqlserver_options.symbolize_keys
         super(name, default, sql_type, null)
+        @primary = @sqlserver_options[:is_identity]
       end
       
       class << self
@@ -74,11 +72,11 @@ module ActiveRecord
       end
       
       def is_utf8?
-        @sql_type =~ /nvarchar|ntext|nchar/i
+        !!(@sql_type =~ /nvarchar|ntext|nchar/i)
       end
       
       def is_integer?
-        @sql_type =~ /int/i
+        !!(@sql_type =~ /int/i)
       end
       
       def sql_type_for_statement
@@ -161,7 +159,7 @@ module ActiveRecord
       include Sqlserver::Errors
       
       ADAPTER_NAME                = 'SQLServer'.freeze
-      VERSION                     = '3.1.0.rc2'.freeze
+      VERSION                     = '3.1.0.rc5'.freeze
       DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+"?(\d{4}|\w+)"?/
       SUPPORTED_VERSIONS          = [2005,2008,2010,2011].freeze
       
@@ -190,6 +188,7 @@ module ActiveRecord
                          rescue
                            0
                          end
+        initialize_dateformatter
         initialize_sqlserver_caches
         use_database
         unless SUPPORTED_VERSIONS.include?(@database_year)
@@ -255,8 +254,6 @@ module ActiveRecord
           @connection.close rescue nil
         when :odbc
           @connection.disconnect rescue nil
-        else :adonet
-          @connection.close rescue nil
         end
       end
       
@@ -409,27 +406,20 @@ module ActiveRecord
                             warn "Ruby ODBC v0.99992 or higher is required."
                           end
                         end
-                      when :adonet
-                        System::Data::SqlClient::SqlConnection.new.tap do |connection|
-                          connection.connection_string = System::Data::SqlClient::SqlConnectionStringBuilder.new.tap do |cs|
-                            if config[:integrated_security]
-                              cs.integrated_security = true
-                            else
-                              cs.user_i_d = config[:username]
-                              cs.password = config[:password]
-                            end
-                            cs.add 'Server', config[:host].to_clr_string
-                            cs.initial_catalog = config[:database]
-                            cs.multiple_active_result_sets = false
-                            cs.pooling = false
-                          end.to_s
-                          connection.open
-                        end
                       end
       rescue
         raise unless @auto_connecting
       end
       
+      def initialize_dateformatter
+        @database_dateformat = user_options['dateformat']
+        a, b, c = @database_dateformat.each_char.to_a
+        [a,b,c].each { |f| f.upcase! if f == 'y' }
+        dateformat = "%#{a}-%#{b}-%#{c}"
+        ::Date::DATE_FORMATS[:_sqlserver_dateformat] = dateformat
+        ::Time::DATE_FORMATS[:_sqlserver_dateformat] = dateformat
+      end
+      
       def remove_database_connections_and_rollback(database=nil)
         database ||= current_database
         do_execute "ALTER DATABASE #{quote_table_name(database)} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"

data/lib/arel/visitors/sqlserver.rb

@@ -6,12 +6,12 @@ module Arel
 
     # Extending the Ordering class to be comparrison friendly which allows us to call #uniq on a
     # collection of them. See SelectManager#order for more details.
-    class Ordering < Arel::Nodes::Binary
+    class Ordering < Arel::Nodes::Unary
       def hash
         expr.hash
       end
       def ==(other)
-        self.class == other.class && self.expr == other.expr
+        other.is_a?(Arel::Nodes::Ordering) && self.expr == other.expr
       end
       def eql?(other)
         self == other
@@ -27,26 +27,25 @@ module Arel
     # to grouping objects for the inner sql during a select statment with an offset/rownumber. So this
     # is here till ActiveRecord & ARel does this for us instead of using SqlLiteral objects.
     alias :order_without_sqlserver :order
-    def order(*exprs)
-      return order_without_sqlserver(*exprs) unless Arel::Visitors::SQLServer === @visitor
-      @ast.orders.concat(exprs.map{ |x|
+    def order(*expr)
+      return order_without_sqlserver(*expr) unless Arel::Visitors::SQLServer === @visitor
+      @ast.orders.concat(expr.map{ |x|
         case x
         when Arel::Attributes::Attribute
           table = Arel::Table.new(x.relation.table_alias || x.relation.name)
-          expr = table[x.name]
-          Arel::Nodes::Ordering.new expr
+          e = table[x.name]
+          Arel::Nodes::Ascending.new e
         when Arel::Nodes::Ordering
           x
         when String
           x.split(',').map do |s|
-            expr, direction = s.split
-            expr = Arel.sql(expr)
-            direction = direction =~ /desc/i ? :desc : :asc
-            Arel::Nodes::Ordering.new expr, direction
+            e, d = s.split
+            e = Arel.sql(e)
+            d =~ /desc/i ? Arel::Nodes::Descending.new(e) : Arel::Nodes::Ascending.new(e)
           end
         else
-          expr = Arel.sql(x.to_s)
-          Arel::Nodes::Ordering.new expr
+          e = Arel.sql(x.to_s)
+          Arel::Nodes::Ascending.new e
         end
       }.flatten)
       self
@@ -89,6 +88,13 @@ module Arel
           visit_Arel_Nodes_SelectStatementWithOutOffset(o)
         end
       end
+      
+      def visit_Arel_Nodes_UpdateStatement(o)
+        if o.orders.any? && o.limit.nil?
+          o.limit = Nodes::Limit.new(2147483647)
+        end
+        super
+      end
 
       def visit_Arel_Nodes_Offset(o)
         "WHERE [__rnt].[__rn] > (#{visit o.expr})"
@@ -101,7 +107,15 @@ module Arel
       def visit_Arel_Nodes_Lock(o)
         visit o.expr
       end
-
+      
+      def visit_Arel_Nodes_Ordering(o)
+        if o.respond_to?(:direction)
+          "#{visit o.expr} #{o.ascending? ? 'ASC' : 'DESC'}"
+        else
+          visit o.expr
+        end
+      end
+      
       def visit_Arel_Nodes_Bin(o)
         "#{visit o.expr} #{@engine.connection.cs_equality_operator}"
       end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
-  hash: 15424097
+  hash: 15424111
   prerelease: 6
   segments: 
   - 3
   - 1
   - 0
   - rc
-  - 2
-  version: 3.1.0.rc2
+  - 5
+  version: 3.1.0.rc5
 platform: ruby
 authors: 
 - Ken Collins
@@ -21,7 +21,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-31 00:00:00 -04:00
+date: 2011-07-26 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,14 +32,14 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15424103
+        hash: 15424111
         segments: 
         - 3
         - 1
         - 0
         - rc
-        - 1
-        version: 3.1.0.rc1
+        - 5
+        version: 3.1.0.rc5
   type: :runtime
   version_requirements: *id001
 description: SQL Server 2005 and 2008 Adapter For ActiveRecord