Reduce the number of queries by caching schema info

Author: fatkodima

lib/active_record_doctor.rb

@@ -19,6 +19,7 @@
 require "active_record_doctor/errors"
 require "active_record_doctor/help"
 require "active_record_doctor/runner"
+require "active_record_doctor/caching_schema_inspector"
 require "active_record_doctor/version"
 require "active_record_doctor/config"
 require "active_record_doctor/config/loader"

lib/active_record_doctor/caching_schema_inspector.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActiveRecordDoctor
+  class CachingSchemaInspector # :nodoc:
+    def initialize(connection)
+      @connection = connection
+      @indexes = {}
+      @foreign_keys = {}
+      @check_constraints = {}
+    end
+
+    def tables
+      @tables ||=
+        if ActiveRecord::VERSION::STRING >= "5.1"
+          @connection.tables
+        else
+          @connection.data_sources
+        end
+    end
+
+    def primary_key(table_name)
+      @connection.schema_cache.primary_keys(table_name)
+    end
+
+    def columns(table_name)
+      @connection.schema_cache.columns(table_name)
+    end
+
+    def indexes(table_name)
+      @indexes.fetch(table_name) do
+        @indexes[table_name] = @connection.indexes(table_name)
+      end
+    end
+
+    def foreign_keys(table_name)
+      @foreign_keys.fetch(table_name) do
+        @foreign_keys[table_name] = @connection.foreign_keys(table_name)
+      end
+    end
+
+    def check_constraints(table_name)
+      @check_constraints.fetch(table_name) do
+        # ActiveRecord 6.1+
+        if @connection.respond_to?(:supports_check_constraints?) && @connection.supports_check_constraints?
+          @connection.check_constraints(table_name).select(&:validated?).map(&:expression)
+        elsif postgresql?
+          definitions =
+            @connection.select_values(<<-SQL)
+              SELECT pg_get_constraintdef(oid, true)
+              FROM pg_constraint
+              WHERE contype = 'c'
+                AND convalidated
+                AND conrelid = #{@connection.quote(table_name)}::regclass
+            SQL
+
+          definitions.map { |definition| definition[/CHECK \((.+)\)/m, 1] }
+        else
+          # We don't support this Rails/database combination yet.
+          []
+        end
+      end
+    end
+
+    def views
+      @views ||=
+        if @connection.respond_to?(:views)
+          @connection.views
+        elsif postgresql?
+          @connection.select_values(<<-SQL)
+            SELECT relname FROM pg_class WHERE relkind IN ('m', 'v')
+          SQL
+        elsif @connection.adapter_name == "Mysql2"
+          @connection.select_values("SHOW FULL TABLES WHERE table_type = 'VIEW'")
+        else
+          # We don't support this Rails/database combination yet.
+          []
+        end
+    end
+
+    private
+
+    def postgresql?
+      ["PostgreSQL", "PostGIS"].include?(@connection.adapter_name)
+    end
+  end
+end

lib/active_record_doctor/detectors/base.rb

@@ -13,8 +13,8 @@ class Base
       class << self
         attr_reader :description
 
-        def run(config, io)
-          new(config, io).run
+        def run(config, schema_inspector, io)
+          new(config, schema_inspector, io).run
         end
 
         def underscored_name
@@ -38,9 +38,10 @@ def locals_and_globals
         end
       end
 
-      def initialize(config, io)
+      def initialize(config, schema_inspector, io)
         @problems = []
         @config = config
+        @schema_inspector = schema_inspector
         @io = io
       end
 
@@ -92,7 +93,7 @@ def connection
       end
 
       def indexes(table_name, except: [])
-        connection.indexes(table_name).reject do |index|
+        @schema_inspector.indexes(table_name).reject do |index|
           except.include?(index.name)
         end
       end
@@ -111,32 +112,22 @@ def tables(except: [])
       end
 
       def primary_key(table_name)
-        primary_key_name = connection.primary_key(table_name)
+        primary_key_name = @schema_inspector.primary_key(table_name)
         return nil if primary_key_name.nil?
 
         column(table_name, primary_key_name)
       end
 
       def column(table_name, column_name)
-        connection.columns(table_name).find { |column| column.name == column_name }
+        columns(table_name).find { |column| column.name == column_name }
+      end
+
+      def columns(table_name)
+        @schema_inspector.columns(table_name)
       end
 
       def views
-        @views ||=
-          if connection.respond_to?(:views)
-            connection.views
-          elsif postgresql?
-            ActiveRecord::Base.connection.select_values(<<-SQL)
-              SELECT relname FROM pg_class WHERE relkind IN ('m', 'v')
-            SQL
-          elsif connection.adapter_name == "Mysql2"
-            ActiveRecord::Base.connection.select_values(<<-SQL)
-              SHOW FULL TABLES WHERE table_type = 'VIEW'
-            SQL
-          else
-            # We don't support this Rails/database combination yet.
-            []
-          end
+        @schema_inspector.views
       end
 
       def not_null_check_constraint_exists?(table, column)
@@ -146,25 +137,12 @@ def not_null_check_constraint_exists?(table, column)
         end
       end
 
+      def foreign_keys(table_name)
+        @schema_inspector.foreign_keys(table_name)
+      end
+
       def check_constraints(table_name)
-        # ActiveRecord 6.1+
-        if connection.respond_to?(:supports_check_constraints?) && connection.supports_check_constraints?
-          connection.check_constraints(table_name).select(&:validated?).map(&:expression)
-        elsif postgresql?
-          definitions =
-            connection.select_values(<<-SQL)
-              SELECT pg_get_constraintdef(oid, true)
-              FROM pg_constraint
-              WHERE contype = 'c'
-                AND convalidated
-                AND conrelid = #{connection.quote(table_name)}::regclass
-            SQL
-
-          definitions.map { |definition| definition[/CHECK \((.+)\)/m, 1] }
-        else
-          # We don't support this Rails/database combination yet.
-          []
-        end
+        @schema_inspector.check_constraints(table_name)
       end
 
       def models(except: [])
@@ -176,10 +154,6 @@ def models(except: [])
       def underscored_name
         self.class.underscored_name
       end
-
-      def postgresql?
-        ["PostgreSQL", "PostGIS"].include?(connection.adapter_name)
-      end
     end
   end
 end

lib/active_record_doctor/detectors/incorrect_boolean_presence_validation.rb

@@ -28,7 +28,7 @@ def detect
         models(except: config(:ignore_models)).each do |model|
           next unless model.table_exists?
 
-          connection.columns(model.table_name).each do |column|
+          columns(model.table_name).each do |column|
             next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
             next unless column.type == :boolean
             next unless has_presence_validator?(model, column)

lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -129,7 +129,7 @@ def dependent_models(model)
       end
 
       def foreign_key(from_table, to_table)
-        connection.foreign_keys(from_table).find do |foreign_key|
+        foreign_keys(from_table).find do |foreign_key|
           foreign_key.to_table == to_table
         end
       end

lib/active_record_doctor/detectors/incorrect_length_validation.rb

@@ -34,7 +34,7 @@ def detect
         models(except: config(:ignore_models)).each do |model|
           next unless model.table_exists?
 
-          connection.columns(model.table_name).each do |column|
+          columns(model.table_name).each do |column|
             next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
             next if ![:string, :text].include?(column.type)
 

lib/active_record_doctor/detectors/mismatched_foreign_key_type.rb

@@ -26,7 +26,7 @@ def message(table:, column:)
 
       def detect
         tables(except: config(:ignore_tables)).each do |table|
-          connection.foreign_keys(table).each do |foreign_key|
+          foreign_keys(table).each do |foreign_key|
             from_column = column(table, foreign_key.column)
 
             next if config(:ignore_columns).include?("#{table}.#{from_column.name}")

lib/active_record_doctor/detectors/missing_foreign_keys.rb

@@ -24,7 +24,7 @@ def message(table:, column:)
 
       def detect
         tables(except: config(:ignore_tables)).each do |table|
-          connection.columns(table).each do |column|
+          columns(table).each do |column|
             next if config(:ignore_columns).include?("#{table}.#{column.name}")
 
             # We need to skip polymorphic associations as they can reference
@@ -44,14 +44,14 @@ def named_like_foreign_key?(column)
       end
 
       def foreign_key?(table, column)
-        connection.foreign_keys(table).any? do |foreign_key|
+        foreign_keys(table).any? do |foreign_key|
           foreign_key.options[:column] == column.name
         end
       end
 
       def polymorphic_foreign_key?(table, column)
         type_column_name = column.name.sub(/_id\Z/, "_type")
-        connection.columns(table).any? do |another_column|
+        columns(table).any? do |another_column|
           another_column.name == type_column_name
         end
       end

lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -33,7 +33,7 @@ def detect
             model.abstract_class? || sti_base_model?(model)
           end
 
-          connection.columns(table).each do |column|
+          columns(table).each do |column|
             next if config(:ignore_columns).include?("#{table}.#{column.name}")
             next if !column.null
             next if !concrete_models.all? { |model| non_null_needed?(model, column) }

lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -26,7 +26,7 @@ def detect
         models(except: config(:ignore_models)).each do |model|
           next unless model.table_exists?
 
-          connection.columns(model.table_name).each do |column|
+          columns(model.table_name).each do |column|
             next unless validator_needed?(model, column)
             next if validator_present?(model, column)
             next if config(:ignore_attributes).include?("#{model}.#{column.name}")