Use deferred join to improve pagination performance (#3983)

* Use deferred join to improve pagination performance

When tables have large number of records using LIMIT and larger values for OFFSET result
in inefficient queries today. Instead of performing the pagination on the whole table,
this technique performs the pagination on a subset of the data. The subset is generated
by a subquery that only looks at the ID column (which is indexed) and then rejoins the result
to the original table. This improve DB query times generated by the SequelPaginator on both
MySQL and Postgres.

This technique has been implemented and works for both pagination using OVER window functions and
without.

Sequel gem supports eager loading and eager graph loading which introduces complications for this
technique, therefore we do not yet support this technique for this method.

Additionally, some paginated queries are not generated from a table, but are simply the result of a
subquery, for example Roles is a union of a permissions, we also explicitly do not perform this
technique on these requests as there is no natural ID field that will have been indexed. We only
do deferred joins when the SQL query "FROM" is from a table (e.g. :apps, "apps").

See https://planetscale.com/learn/courses/mysql-for-developers/examples/deferred-joins

* Only remove SequelPaginator tmp field when present

Author: Samze

lib/cloud_controller/paging/sequel_paginator.rb

@@ -18,7 +18,7 @@ def get_page(dataset, pagination_options)
       records, count = if can_paginate_with_window_function?(dataset)
                          paginate_with_window_function(dataset, per_page, page, table_name)
                        else
-                         paginate_with_extension(dataset, per_page, page)
+                         paginate_with_extension(dataset, per_page, page, table_name)
                        end
 
       PaginatedResult.new(records, count, pagination_options)
@@ -34,20 +34,56 @@ def can_paginate_with_window_function?(dataset)
 
     def paginate_with_window_function(dataset, per_page, page, table_name)
       dataset = dataset.from_self if dataset.opts[:distinct]
-      dataset = if dataset.opts[:graph]
-                  dataset.add_graph_aliases(pagination_total_results: [table_name, :pagination_total_results, Sequel.function(:count).*.over])
-                else
-                  dataset.select_append(Sequel.as(Sequel.function(:count).*.over, :pagination_total_results))
-                end
-      records = dataset.limit(per_page, (page - 1) * per_page).all
+
+      paged_dataset = dataset.limit(per_page, (page - 1) * per_page)
+
+      paged_dataset = if dataset.opts[:graph]
+                        paged_dataset.add_graph_aliases(pagination_total_results: [table_name, :pagination_total_results, Sequel.function(:count).*.over])
+                      elsif from_is_table?(dataset)
+                        dataset.join_table(
+                          :inner,
+                          paged_dataset.select(Sequel[table_name][:id].as(:tmp_deferred_id)).
+                              select_append(Sequel.as(Sequel.function(:count).*.over, :pagination_total_results)).
+                              as(:tmp_deferred_table),
+                          Sequel[table_name][:id] => Sequel[:tmp_deferred_table][:tmp_deferred_id]
+                        ).select_append(:pagination_total_results)
+                      else
+                        paged_dataset.select_append(Sequel.as(Sequel.function(:count).*.over, :pagination_total_results))
+                      end
+
+      records = paged_dataset.all
+
       count = records.any? ? records.first[:pagination_total_results] : 0
-      records.each { |x| x.values.delete(:pagination_total_results) }
+
+      records.each do |x|
+        x.values.delete(:pagination_total_results)
+        x.values.delete(:tmp_deferred_id)
+      end
+      [records, count]
+    end
+
+    def paginate_with_extension(dataset, per_page, page, table_name)
+      paged_dataset = dataset.extension(:pagination).paginate(page, per_page)
+      count = paged_dataset.pagination_record_count
+
+      if from_is_table?(dataset)
+        paged_dataset = dataset.join_table(
+          :inner,
+          paged_dataset.select(Sequel[table_name][:id].as(:tmp_deferred_id)).as(:tmp_deferred_table),
+          Sequel[table_name][:id] => Sequel[:tmp_deferred_table][:tmp_deferred_id]
+        )
+      end
+
+      records = paged_dataset.all
+
+      has_tmp_deferred_id = records.first&.keys&.include?(:tmp_deferred_id)
+      records.each { |x| x.values.delete(:tmp_deferred_id) } if has_tmp_deferred_id
+
       [records, count]
     end
 
-    def paginate_with_extension(dataset, per_page, page)
-      query = dataset.extension(:pagination).paginate(page, per_page)
-      [query.all, query.pagination_record_count]
+    def from_is_table?(dataset)
+      [Symbol, String].include?(dataset.opts[:from].first.class)
     end
   end
 end

spec/unit/lib/cloud_controller/paging/sequel_paginator_spec.rb

@@ -13,6 +13,8 @@ module VCAP::CloudController
       let!(:app_model2) { AppModel.make }
       let!(:app_model3) { AppModel.make }
       let!(:app_model4) { AppModel.make }
+      let!(:space_manager_model) { SpaceManager.make }
+      let!(:space_developer_model) { SpaceDeveloper.make }
       let(:page) { 1 }
       let(:per_page) { 1 }
 
@@ -96,6 +98,49 @@ module VCAP::CloudController
         expect(paginated_result.records[0].associations[:space].name).to eq(space.name)
       end
 
+      it 'works when pages are generated from a subquery' do
+        options = { page: page, per_page: per_page, order_by: :guid }
+        pagination_options = PaginationOptions.new(options)
+        dataset = Role.dataset
+        paginated_result = nil
+        expect do
+          paginated_result = paginator.get_page(dataset, pagination_options)
+        end.to have_queried_db_times(/select/i, paginator.can_paginate_with_window_function?(dataset) ? 1 : 2)
+        expect(paginated_result.total).to eq(2)
+      end
+
+      context 'when not using window functions' do
+        let(:my_config) do
+          {
+            db: {
+              enable_paginate_window: false
+            }
+          }
+        end
+
+        before do
+          TestConfig.override(**my_config)
+        end
+
+        it 'works when pages are generated from a subquery' do
+          options = { page: page, per_page: per_page, order_by: :guid }
+          pagination_options = PaginationOptions.new(options)
+          dataset = Role.dataset
+          paginated_result = nil
+          expect do
+            paginated_result = paginator.get_page(dataset, pagination_options)
+          end.to have_queried_db_times(/select/i, 2)
+          expect(paginated_result.total).to eq(2)
+        end
+      end
+
+      it 'paged results do not contain extra columns' do
+        options = { page:, per_page: }
+        pagination_options = PaginationOptions.new(options)
+        paginated_result = paginator.get_page(dataset, pagination_options)
+        expect(paginated_result.records.first.keys).to match_array(AppModel.columns)
+      end
+
       it 'orders by GUID as a secondary field when available' do
         options = { page: page, per_page: 2, order_by: 'created_at', order_direction: 'asc' }
         app_model1.update(guid: '1', created_at: '2019-12-25T13:00:00Z')