feat(active-record): improve performance when a belongsTo relation is included (#729)

Author: nicolasalexandre9

app/services/forest_liana/resources_getter.rb

@@ -30,7 +30,20 @@ def self.get_ids_from_request(params, user)
     end
 
     def perform
-      @records = optimize_record_loading(@resource, @records)
+      polymorphic_association, preload_loads = analyze_associations(@resource)
+      includes = @includes.uniq - polymorphic_association - preload_loads
+      has_smart_fields =  @params[:fields][@collection_name].split(',').any? do |field|
+        ForestLiana::SchemaHelper.is_smart_field?(@resource, field)
+      end
+
+      if includes.empty? || has_smart_fields
+        @records = optimize_record_loading(@resource, @records)
+      else
+        select = compute_select_fields
+        @records = optimize_record_loading(@resource, @records).references(includes).select(*select)
+      end
+
+      @records
     end
 
     def count
@@ -210,5 +223,29 @@ def limit
     def pagination?
       @params[:page]&.dig(:number)
     end
+
+    def compute_select_fields
+      select = ['_forest_admin_eager_load']
+      @params[:fields][@collection_name].split(',').each do |path|
+        if @params[:fields].key?(path)
+          association = ForestLiana::QueryHelper.get_one_associations(@resource)
+                                                .select { |association| association.name == path.to_sym }
+                                                .first
+          table_name = association.table_name
+
+          @params[:fields][path].split(',').each do |association_path|
+            if ForestLiana::SchemaHelper.is_smart_field?(association.klass, association_path)
+              association.klass.attribute_names.each { |attribute| select << "#{table_name}.#{attribute}" }
+            else
+              select << "#{table_name}.#{association_path}"
+            end
+          end
+        else
+          select << "#{@resource.table_name}.#{path}"
+        end
+      end
+
+      select
+    end
   end
 end

lib/forest_liana/active_record_override.rb

@@ -0,0 +1,65 @@
+module ForestLiana
+  module ActiveRecordOverride
+    module Associations
+      require 'active_record/associations/join_dependency'
+      module JoinDependency
+        def apply_column_aliases(relation)
+          if !(@join_root_alias = relation.select_values.empty?) &&
+            relation.select_values.first.to_s == '_forest_admin_eager_load'
+
+            relation.select_values.shift
+            used_cols = {}
+            # Find and expand out all column names being used in select(...)
+            new_select_values = relation.select_values.map(&:to_s).each_with_object([]) do |col, select|
+              unless col.include?(' ') # Pass it through if it's some expression (No chance for a simple column reference)
+                col = if (col_parts = col.split('.')).length == 1
+                  [col]
+                else
+                  [col_parts[0..-2].join('.'), col_parts.last]
+                end
+                used_cols[col] = nil
+              end
+              select << col
+            end
+
+            if new_select_values.present?
+              relation.select_values = new_select_values
+            else
+              relation.select_values.clear
+            end
+
+            @aliases ||= ActiveRecord::Associations::JoinDependency::Aliases.new(join_root.each_with_index.map do |join_part, i|
+              join_alias = join_part.table&.table_alias || join_part.table_name
+              keys = [join_part.base_klass.primary_key] # Always include the primary key
+
+              # # %%% Optional to include all foreign keys:
+              # keys.concat(join_part.base_klass.reflect_on_all_associations.select { |a| a.belongs_to? }.map(&:foreign_key))
+              # Add foreign keys out to referenced tables that we belongs_to
+              join_part.children.each { |child| keys << child.reflection.foreign_key if child.reflection.belongs_to? }
+
+              # Add the foreign key that got us here -- "the train we rode in on" -- if we arrived from
+              # a has_many or has_one:
+              if join_part.is_a?(ActiveRecord::Associations::JoinDependency::JoinAssociation) &&
+                !join_part.reflection.belongs_to?
+                keys << join_part.reflection.foreign_key
+              end
+              keys = keys.compact # In case we're using composite_primary_keys
+              j = 0
+              columns = join_part.column_names.each_with_object([]) do |column_name, s|
+                # Include columns chosen in select(...) as well as the PK and any relevant FKs
+                if used_cols.keys.find { |c| (c.length == 1 || c.first == join_alias) && c.last == column_name } ||
+                  keys.find { |c| c == column_name }
+                  s << ActiveRecord::Associations::JoinDependency::Aliases::Column.new(column_name, "t#{i}_r#{j}")
+                end
+                j += 1
+              end
+              ActiveRecord::Associations::JoinDependency::Aliases::Table.new(join_part, columns)
+            end)
+            relation.select_values.clear
+          end
+          relation._select!(-> { aliases.columns })
+        end
+      end
+    end
+  end
+end

lib/forest_liana/engine.rb

@@ -7,6 +7,7 @@
 require 'bcrypt'
 require_relative 'bootstrapper'
 require_relative 'collection'
+require_relative 'active_record_override'
 
 module Rack
   class Cors
@@ -90,6 +91,12 @@ def eager_load_active_record_descendants app
       end
     end
 
+    initializer 'forest_liana.override_active_record_dependency' do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Associations::JoinDependency.prepend(ForestLiana::ActiveRecordOverride::Associations::JoinDependency)
+      end
+    end
+
     config.after_initialize do |app|
       if error
         FOREST_REPORTER.report error

spec/services/forest_liana/resources_getter_spec.rb

@@ -4,7 +4,7 @@ module ForestLiana
     let(:pageSize) { 10 }
     let(:pageNumber) { 1 }
     let(:sort) { 'id' }
-    let(:fields) {}
+    let(:fields) { { resource.name => 'id' } }
     let(:filters) {}
     let(:scopes) { {'scopes' => {}, 'team' => {'id' => '1', 'name' => 'Operations'}} }
     let(:rendering_id) { 13 }
@@ -190,6 +190,7 @@ def association_connection.current_database
 
     describe 'when on a model having a reserved SQL word as name' do
       let(:resource) { Reference }
+      let(:fields) { { resource.name => 'id' } }
 
       it 'should get the ressource properly' do
         getter.perform
@@ -219,6 +220,7 @@ def association_connection.current_database
 
     describe 'when sorting by a belongs_to association' do
       let(:resource) { Tree }
+      let(:fields) { { resource.name => 'id' } }
       let(:sort) { 'owner.name' }
 
       it 'should get only the expected records' do
@@ -501,7 +503,7 @@ def association_connection.current_database
     describe 'when scopes are defined' do
       let(:resource) { Island }
       let(:pageSize) { 15 }
-      let(:fields) { }
+      let(:fields) { { resource.name => 'id' } }
       let(:filters) { }
       let(:scopes) {
         {