Implement association limiting after a fashion from PostgreSQL using #add_order_by_for_association_limiting!

Author: metaskills

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -488,25 +488,12 @@ def type_to_sql(type, limit = nil, precision = nil, scale = nil)
       end
 
       def add_order_by_for_association_limiting!(sql, options)
+        # Disertation http://gist.github.com/24073
+        # Information http://weblogs.sqlteam.com/jeffs/archive/2007/12/13/select-distinct-order-by-error.aspx
         return sql if options[:order].blank?
-        # Strip any ASC or DESC from the orders for the select list
-        # Build fields and order arrays
-        # e.g.: options[:order] = 'table.[id], table2.[col2] desc'
-        # fields = ['min(table.[id]) AS id', 'min(table2.[col2]) AS col2']
-        # order = ['id', 'col2 desc']
-        fields = []
-        order = []
-        options[:order].split(/\s*,\s*/).each do |str|
-          # regex matches 'table_name.[column_name] asc' or 'column_name' ('table_name.', 'asc', '[', and ']' are optional)
-          # $1 = 'table_name.[column_name]'
-          # $2 = 'column_name'
-          # $3 = ' asc'
-          str =~ /((?:\w+\.)?\[?(\w+)\]?)(\s+asc|\s+desc)?/i
-          fields << "MIN(#{$1}) AS #{$2}"
-          order << "#{$2}#{$3}"
-        end
-        sql.gsub!(/(.+?) FROM/, "\\1, #{fields.join(',')} FROM")
-        sql << " ORDER BY #{order.join(',')}"
+        columns = sql.match(/SELECT\s+DISTINCT(.*)FROM/)[1].strip
+        sql.sub!(/SELECT\s+DISTINCT/,'SELECT')
+        sql << "GROUP BY #{columns} ORDER BY #{order_to_min_set(options[:order])}"
       end
 
       def change_column_null(table_name, column_name, null, default = nil)
@@ -713,6 +700,19 @@ def get_table_name(sql)
         end
       end
 
+      def order_to_min_set(order)
+        dir = ''
+        orders = order.split(',').map(&:strip).reject(&:blank?)
+        mins = orders.map do |o|
+          if o =~ /\b(asc|desc)$/i
+            dir = $1
+            o = o.sub($1,'').strip
+          end
+          "MIN(#{o})"
+        end
+        "#{mins.join(', ')} #{dir}".strip
+      end
+      
       def remove_sqlserver_columns_cache_for(table_name)
         cache_key = unqualify_table_name(table_name)
         @sqlserver_columns_cache[cache_key] = nil

lib/core_ext/active_record.rb

@@ -16,50 +16,8 @@ def reset_column_information_with_sqlserver_columns_cache_support
           reset_column_information_without_sqlserver_columns_cache_support
         end
 
-        private
-        
-        # Overwrite the ActiveRecord::Base method for SQL server.
-        # GROUP BY is necessary for distinct orderings
-        def construct_finder_sql_for_association_limiting(options, join_dependency)
-          scope       = scope(:find)
-          is_distinct = !options[:joins].blank? || include_eager_conditions?(options) || include_eager_order?(options)
-
-          sql = "SELECT #{table_name}.#{connection.quote_column_name(primary_key)} FROM #{table_name} "
-
-          if is_distinct
-            sql << join_dependency.join_associations.collect(&:association_join).join
-            # merge_joins isn't defined in 2.1.1, but appears in edge
-            if defined?(merge_joins)
-            # The next line may fail with a nil error under 2.1.1 or other non-edge rails versions - Use this instead: add_joins!(sql, options, scope)
-             add_joins!(sql, options[:joins], scope)
-            else
-             add_joins!(sql, options, scope)
-            end
-          end
-
-          add_conditions!(sql, options[:conditions], scope)
-          add_group!(sql, options[:group], scope)
-
-          if options[:order] && is_distinct
-            if sql =~ /GROUP\s+BY/i
-              sql << ", #{table_name}.#{connection.quote_column_name(primary_key)}"
-            else
-              sql << " GROUP BY #{table_name}.#{connection.quote_column_name(primary_key)}"
-            end #if sql =~ /GROUP BY/i
-
-            connection.add_order_by_for_association_limiting!(sql, options)
-          else
-            add_order!(sql, options[:order], scope)
-          end
-
-          add_limit!(sql, options, scope)
-
-          return sanitize_sql(sql)
-        end
-        
       end
 
-      
     end
   end
 end

test/cases/adapter_test_sqlserver.rb

@@ -117,6 +117,17 @@ def setup
 
     end
 
+    should 'take all types of order options and convert them to MIN functions using #order_to_min_set' do
+      single_order = 'comments.id'
+      assert_equal 'MIN(comments.id)', @connection.send(:order_to_min_set,single_order)
+      two_orders = 'comments.id, comments.post_id'
+      assert_equal 'MIN(comments.id), MIN(comments.post_id)', @connection.send(:order_to_min_set,two_orders)
+      single_order_with_desc = 'comments.id DESC'
+      assert_equal 'MIN(comments.id) DESC', @connection.send(:order_to_min_set,single_order_with_desc)
+      two_orders_with_asc = 'comments.id, comments.post_id ASC'
+      assert_equal 'MIN(comments.id), MIN(comments.post_id) ASC', @connection.send(:order_to_min_set,two_orders_with_asc)
+    end
+    
     context 'with different language' do
 
       teardown do