keep the ordering when fetching previous records

Author: GCorbel

lib/mongoid/criteria/scrollable.rb

@@ -11,17 +11,15 @@ def scroll(cursor_or_type = nil, &_block)
         criteria.merge!(default_sort) if no_sort_option?
         cursor_options = build_cursor_options(criteria)
         cursor = cursor.is_a?(cursor_type) ? cursor : new_cursor(cursor_type, cursor, cursor_options)
-        direction = scroll_direction(criteria)
         raise_mismatched_sort_fields_error!(cursor, cursor_options) if different_sort_fields?(cursor, cursor_options)
-        cursor_criteria = build_cursor_criteria(criteria, cursor)
-        first_in_page = nil
+        records = find_records(criteria, cursor)
         if block_given?
-          cursor_criteria.order_by(_id: direction).each do |record|
-            first_in_page ||= record
-            yield record, cursor_from_record(cursor_type, record, cursor_options), cursor_from_record(cursor_type, first_in_page, cursor_options.merge(previous: true))
+          first_cursor = cursor_from_record(cursor_type, records.first, cursor_options.merge(previous: true))
+          records.each do |record|
+            yield record, cursor_from_record(cursor_type, record, cursor_options), first_cursor
           end
         else
-          cursor_criteria
+          records
         end
       end
 
@@ -63,10 +61,21 @@ def new_cursor(cursor_type, cursor, cursor_options)
         cursor_type.new(cursor, cursor_options)
       end
 
-      def build_cursor_criteria(criteria, cursor)
+      def find_records(criteria, cursor)
         cursor_criteria = criteria.dup
         cursor_criteria.selector = { '$and' => [criteria.selector, cursor.criteria] }
-        cursor_criteria
+        if cursor.previous && criteria.options[:limit]
+          pipeline = [
+            { '$match' => cursor_criteria.selector },
+            { '$sort' => { cursor.field_name => -cursor.direction } },
+            { '$limit' => criteria.options[:limit] },
+            { '$sort' => { cursor.field_name => cursor.direction } }
+          ]
+          aggregation = cursor_criteria.view.aggregate(pipeline)
+          aggregation.map { Mongoid::Factory.from_db(cursor_criteria.klass, _1) }
+        else
+          cursor_criteria.order_by(_id: scroll_direction(criteria))
+        end
       end
 
       def cursor_from_record(cursor_type, record, cursor_options)

spec/mongoid/criteria_spec.rb

@@ -161,23 +161,26 @@
               end
             end
             it 'can scroll back with the previous cursor' do
-              first_cursor = nil
-              second_cursor = nil
+              cursor = nil
+              first_previous_cursor = nil
+              second_previous_cursor = nil
 
               Feed::Item.asc(field_name).limit(2).scroll(cursor_type) do |_, next_cursor|
-                second_cursor = next_cursor
+                cursor = next_cursor
               end
-              Feed::Item.asc(field_name).limit(2).scroll(second_cursor) do |_, _, previous_cursor|
-                first_cursor = previous_cursor
+
+              Feed::Item.asc(field_name).limit(2).scroll(cursor) do |_, next_cursor, previous_cursor|
+                cursor = next_cursor
+                first_previous_cursor = previous_cursor
               end
 
-              records = []
-              Feed::Item.asc(field_name).limit(2).scroll(first_cursor) do |record|
-                records << record
+              Feed::Item.asc(field_name).limit(2).scroll(cursor) do |_, _, previous_cursor|
+                second_previous_cursor = previous_cursor
               end
-              expect(records).to eq Feed::Item.asc(field_name).limit(2).to_a
 
-              expect(Feed::Item.asc(field_name).scroll(first_cursor).to_a).to eq Feed::Item.asc(field_name).limit(2).to_a
+              records = Feed::Item.asc(field_name)
+              expect(Feed::Item.asc(field_name).limit(2).scroll(first_previous_cursor)).to eq(records.limit(2))
+              expect(Feed::Item.asc(field_name).limit(2).scroll(second_previous_cursor)).to eq(records.skip(2).limit(2))
             end
           end
         end