brick 1.0.199 → 1.0.201

data/lib/brick/extensions.rb

@@ -334,10 +334,10 @@ module ActiveRecord
     end
 
     # Providing a relation object allows auto-modules built from table name prefixes to work
-    def self._brick_index(mode = nil, separator = nil, relation = nil)
+    def self._brick_index(mode = nil, separator = nil, relation = nil, not_path = nil)
       return if abstract_class?
 
-      ::Brick._brick_index(table_name, mode, separator, relation)
+      ::Brick._brick_index(table_name, mode, separator, relation, not_path)
     end
 
     def self.brick_import_template
@@ -436,7 +436,11 @@ module ActiveRecord
       order_by = ordering&.each_with_object([]) do |ord_part, s| # %%% If a term is also used as an eqi-condition in the WHERE clause, it can be omitted from ORDER BY
                    case ord_part
                    when String
-                     ord_expr = _br_quoted_name(ord_part.gsub('^^^', table_name))
+                     ord_expr = if ord_part.index('(') # Any kind of SQL function at play here?
+                                  ord_part.gsub('^^^', _br_quoted_name(table_name))
+                                else
+                                  _br_quoted_name(ord_part.gsub('^^^', table_name))
+                                end
                      s << Arel.sql(ord_expr)
                      order_by_txt&.<<(ord_expr.index('.') ? "Arel.sql(#{ord_expr.inspect})" : ord_part.inspect)
                    else # Expecting only Symbol
@@ -887,12 +891,16 @@ module ActiveRecord
 
         tbl_alias = unique63("b_r_#{hm.name}", previous)
         on_clause = []
-        hm_selects = if fk_col.is_a?(Array) # Composite key?
-                       fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl.table_name}.#{pri_key[idx]}" }
-                       fk_col.dup
-                     else
+        hm_selects = if !pri_key.is_a?(Array) # Probable standard key?
+                       if fk_col.is_a?(Array) # Foreign is composite but not Primary?  OK, or choose the first part of the foreign key if nothing else
+                         fk_col = fk_col.find { |col_name| col_name == pri_key } || # Try to associate with the same-named part of the foreign key ...
+                                  fk_col.first # ... and if no good match, just choose the first part
+                       end
                        on_clause << "#{_br_quoted_name("#{tbl_alias}.#{fk_col}")} = #{_br_quoted_name("#{pri_tbl.table_name}.#{pri_key}")}"
                        [fk_col]
+                     else # Composite key
+                       fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl.table_name}.#{pri_key[idx]}" }
+                       fk_col.dup
                      end
         if poly_type
           hm_selects << poly_type
@@ -1166,6 +1174,34 @@ Might want to add this in your brick.rb:
   end
 end
 
+if ::Brick.enable_routes? && Object.const_defined?('ActionDispatch')
+  require 'brick/route_mapper'
+  ActionDispatch::Routing::RouteSet.class_exec do
+    # In order to defer auto-creation of any routes that already exist, calculate Brick routes only after having loaded all others
+    prepend ::Brick::RouteSet
+  end
+  ActionDispatch::Routing::Mapper.class_exec do
+    include ::Brick::RouteMapper
+  end
+
+  # Do the root route before the Rails Welcome one would otherwise take precedence
+  if (route = ::Brick.config.default_route_fallback).present?
+    action = "#{route}#{'#index' unless route.index('#')}"
+    if ::Brick.config.path_prefix
+      ::Rails.application.routes.append do
+        send(:namespace, ::Brick.config.path_prefix) do
+          send(:root, action)
+        end
+      end
+    elsif ::Rails.application.routes.named_routes.send(:routes)[:root].nil?
+      ::Rails.application.routes.append do
+        send(:root, action)
+      end
+    end
+    ::Brick.established_drf = "/#{::Brick.config.path_prefix}#{action[action.index('#')..-1]}"
+  end
+end
+
 if Object.const_defined?('ActionView')
   require 'brick/frameworks/rails/form_tags'
   require 'brick/frameworks/rails/form_builder'
@@ -1298,19 +1334,23 @@ end
     unless (is_tnp_module = (is_brick_prefix && !is_controller && ::Brick.config.table_name_prefixes.values.include?(requested)))
       # ... first look around for an existing module or class.
       desired_classname = (self == Object || !name) ? requested : "#{name}::#{requested}"
-      if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) &&
+      if (self.const_defined?(args.first) && (possible = self.const_get(args.first)) &&
           # Reset `possible` if it's a controller request that's not a perfect match
           # Was:  (possible = nil)  but changed to #local_variable_set in order to suppress the "= should be ==" warning
           (possible&.name == desired_classname || (is_controller && binding.local_variable_set(:possible, nil)))) ||
+
          # Try to require the respective Ruby file
+         # ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore)) &&
+         #  (require_dependency(filename) || true) &&
          ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
                       (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = requested).underscore))
           ) && (require_dependency(filename) || true) &&
-          ((possible = self.const_get(args.first)) && possible.name == desired_classname)
+          (!anonymous? && (possible = self.const_get(args.first)) && possible.name == desired_classname)
          ) ||
+
          # If any class has turned up so far (and we're not in the middle of eager loading)
          # then return what we've found.
-         (is_defined && !::Brick.is_eager_loading) # Used to also have:   && possible != self
+         (possible&.module_parent == base_module && !::Brick.is_eager_loading) # Used to also have:   && possible != self
         if ((!brick_root && (filename || possible.instance_of?(Class))) ||
             (possible.instance_of?(Module) && possible&.module_parent == self) ||
             (possible.instance_of?(Class) && possible == self)) && # Are we simply searching for ourselves?
@@ -1326,13 +1366,14 @@ end
       end
     end
     class_name = ::Brick.namify(requested)
+    is_avo_present = Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace)
     #        CONTROLLER
     result = if ::Brick.enable_controllers? &&
                 is_controller && (plural_class_name = class_name[0..-11]).length.positive?
                # Otherwise now it's up to us to fill in the gaps
                controller_class_name = +''
                full_class_name = +''
-               unless self == Object
+               unless self == Object || (is_avo_present && self.name == 'Avo')
                  controller_class_name << ((split_self_name&.first && split_self_name.join('::')) || self.name)
                  full_class_name << "::#{controller_class_name}"
                  controller_class_name << '::'
@@ -1342,13 +1383,14 @@ end
                singular_class_name = ::Brick.namify(plural_class_name, :underscore).singularize.camelize
                full_class_name << "::#{singular_class_name}"
                skip_controller = nil
-               if plural_class_name == 'BrickOpenapi' ||
-                  (
-                    (::Brick.config.add_status || ::Brick.config.add_orphans) &&
-                    plural_class_name == 'BrickGem'
-                  ) ||
-                 begin
-                   model = self.const_get(full_class_name)
+               begin
+                 if plural_class_name == 'BrickOpenapi' ||
+                    (
+                      (::Brick.config.add_status || ::Brick.config.add_orphans) &&
+                      plural_class_name == 'BrickGem'
+                    # Was:  ) || (model = self.const_get(full_class_name))
+                    ) || (model = Object.const_get(full_class_name))
+                   # puts "#{self.name} - #{full_class_name}"
 
                    # In the very rare case that we've picked up a MODULE which has the same name as what would be the
                    # resource's MODEL name, just build out an appropriate auto-model on-the-fly. (RailsDevs code has this in PayCustomer.)
@@ -1356,10 +1398,10 @@ end
                    if model && !model.is_a?(Class)
                      model, _code = Object.send(:build_model, relations, model.module_parent, model.module_parent.name, singular_class_name)
                    end
-                 rescue NameError # If the const_get for the model has failed...
-                   skip_controller = true
-                   # ... then just fall through and allow it to fail when trying to load the ____Controller class normally.
                  end
+               rescue NameError # If the const_get for the model has failed...
+                 skip_controller = true
+                 # ... then just fall through and allow it to fail when trying to load the ____Controller class normally.
                end
                unless skip_controller
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
@@ -1391,58 +1433,43 @@ end
                base_module.const_set(class_name.to_sym, (built_module = Module.new))
                [built_module, "module #{possible_module}; end\n"]
 
-             # AVO Resource
-             elsif base_module == Object && Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) && requested.end_with?('Resource') &&
+             # AVO 2.x Resource
+             elsif base_module == Object && is_avo_present && requested.end_with?('Resource') &&
                    # Expect that anything called MotorResource or SpinaResource could be from those administrative gems
-                   requested.length > 8 && ['MotorResource', 'SpinaResource'].exclude?(requested)
-               if (model = Object.const_get(requested[0..-9])) && model < ActiveRecord::Base
-                 require 'generators/avo/resource_generator'
-                 field_generator = Generators::Avo::ResourceGenerator.new([''])
-                 field_generator.instance_variable_set(:@model, model)
-                 fields = field_generator.send(:generate_fields)&.split("\n")
-                                         &.each_with_object([]) do |f, s|
-                                           if (f = f.strip).start_with?('field ')
-                                             f = f[6..-1].split(',')
-                                             s << [f.first[1..-1].to_sym, [f[1][1..-1].split(': :').map(&:to_sym)].to_h]
-                                           end
-                                         end || []
-                 built_resource = Class.new(Avo::BaseResource) do |new_resource_class|
-                   self.model_class = model
-                   self.title = :brick_descrip
-                   self.includes = []
-                   if (!model.is_view? && mod_pk = model.primary_key)
-                     field((mod_pk.is_a?(Array) ? mod_pk.first : mod_pk).to_sym, { as: :id })
-                   end
-                   # Create a call such as:  field :name, as: :text
-                   fields.each do |f|
-                     # Add proper types if this is a polymorphic belongs_to
-                     if f.last == { as: :belongs_to } &&
-                        (fk = ::Brick.relations[model.table_name][:fks].find { |k, v| v[:assoc_name] == f.first.to_s }) &&
-                        fk.last.fetch(:polymorphic, nil)
-                       poly_types = fk.last.fetch(:inverse_table, nil)&.each_with_object([]) do |poly_table, s|
-                         s << Object.const_get(::Brick.relations[poly_table][:class_name])
-                       end
-                       if poly_types.present?
-                         f.last[:polymorphic_as] = f.first
-                         f.last[:types] = poly_types
-                       end
-                     end
-                     self.send(:field, *f)
-                   end
-                 end
-                 Object.const_set(requested.to_sym, built_resource)
-                 [built_resource, nil]
+                   requested.length > 8 && ['MotorResource', 'SpinaResource'].exclude?(requested) &&
+                   (model = Object.const_get(requested[0..-9])) && model < ActiveRecord::Base
+               built_resource = Class.new(Avo::BaseResource) do
+                 self.model_class = model
+                 self.title = :brick_descrip
+                 self.includes = []
+                 ::Brick::ADD_AVO_FIELDS.call(self, model)
                end
+               base_module.const_set(requested.to_sym, built_resource)
+               [built_resource, nil]
+
+             # AVO 3.x Resource
+             elsif is_avo_present && self.name == 'Avo::Resources' &&
+                   (model = begin
+                              (model = Object.const_get(requested)) && model < ActiveRecord::Base
+                              model
+                            rescue
+                            end)
+               [::Brick.avo_3x_resource(model, requested), nil]
 
              # MODEL
              elsif ::Brick.enable_models?
+               # Avo sometimes tries to find a model class inside of the Avo namespace
+               if is_avo_present && self.name == 'Avo'
+                 name = (base_module = Object).name
+               end
+               name ||= base_module.name
                # Custom inheritable Brick base model?
                class_name = (inheritable_name = class_name)[5..-1] if class_name.start_with?('Brick')
                Object.send(:build_model, relations, base_module, name, class_name, inheritable_name)
              end
     if result
       built_class, code = result
-      puts "\n#{code}\n"
+      puts "\n#{code}\n" if code
       built_class
     elsif !schema_name && ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}")
 #         module_prefixes = type_name.split('::')
@@ -1452,7 +1479,7 @@ end
       base_module._brick_const_missing(*args)
     # elsif base_module != Object
     #   module_parent.const_missing(*args)
-    elsif Rails.respond_to?(:autoloaders) && # After finding nothing else, if Zeitwerk is enabled ...
+    elsif Object.const_defined?('Rails') && ::Rails.respond_to?(:autoloaders) && # After finding nothing else, if Zeitwerk is enabled ...
           (Rails::Autoloaders.respond_to?(:zeitwerk_enabled?) ? Rails::Autoloaders.zeitwerk_enabled? : true)
       self._brick_const_missing(*args) # ... rely solely on Zeitwerk.
     else # Classic mode
@@ -1471,13 +1498,63 @@ end
   end
 end
 
+module Brick
+  def self.avo_3x_resource(model, requested)
+    built_resource = Class.new(Avo::BaseResource) do
+      self.model_class = model
+      self.title = :brick_descrip
+      self.includes = []
+      define_method :fields do # Have to be inside of a fields method
+        ::Brick::ADD_AVO_FIELDS.call(self, model)
+      end
+    end
+    ::Avo::BaseResource.const_set(requested.to_sym, built_resource)
+    built_resource
+  end
+end
+
+::Brick::ADD_AVO_FIELDS = lambda do |obj, model|
+  require 'generators/avo/resource_generator'
+  field_generator = Generators::Avo::ResourceGenerator.new([''])
+  field_generator.instance_variable_set(:@model, model)
+  flds = field_generator.send(:generate_fields)&.split("\n")
+                        &.each_with_object([]) do |f, s|
+                          if (f = f.strip).start_with?('field ')
+                            f = f[6..-1].split(',')
+                            s << [f.first[1..-1].to_sym, [f[1][1..-1].split(': :').map(&:to_sym)].to_h]
+                          end
+                        end || []
+  if (!model.is_view? && mod_pk = model.primary_key)
+    obj.field((mod_pk.is_a?(Array) ? mod_pk.first : mod_pk).to_sym, **{ as: :id })
+  end
+  # Create a call such as:  field :name, as: :text
+  flds.each do |f|
+    # Add proper types if this is a polymorphic belongs_to
+    if f.last == { as: :belongs_to } &&
+       (fk = ::Brick.relations[model.table_name][:fks].find { |k, v| v[:assoc_name] == f.first.to_s }) &&
+       fk.last.fetch(:polymorphic, nil)
+      poly_types = fk.last.fetch(:inverse_table, nil)&.each_with_object([]) do |poly_table, s|
+        s << Object.const_get(::Brick.relations[poly_table][:class_name])
+      end
+      if poly_types.present?
+        f.last[:polymorphic_as] = f.first
+        f.last[:types] = poly_types
+      end
+    end
+    kwargs = f.last.is_a?(Hash) ? f.pop : {}
+    obj.send(:field, *f, **kwargs)
+  end
+end
+
 class Object
   class << self
 
   private
 
     def build_model(relations, base_module, base_name, class_name, inheritable_name = nil)
-      tnp = ::Brick.config.table_name_prefixes&.find { |p| p.last == base_module.name }&.first
+      tnp = ::Brick.config.table_name_prefixes&.find { |p| p.last == base_module.name }
+      # return [base_module, ''] if !base_module.is_a?(Class) && base_name == tnp&.last
+
       if (base_model = (::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::#{class_name}", nil) || # Are we part of an auto-STI namespace? ...
                         ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil))&.constantize) ||
          base_module != Object # ... or otherwise already in some namespace?
@@ -1499,7 +1576,7 @@ class Object
         table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
                        base_model.table_name
                      else
-                       "#{tnp}#{ActiveSupport::Inflector.pluralize(singular_table_name)}"
+                       "#{tnp&.first}#{ActiveSupport::Inflector.pluralize(singular_table_name)}"
                      end
         if ::Brick.apartment_multitenant &&
            Apartment.excluded_models.include?(table_name.singularize.camelize)
@@ -1553,7 +1630,7 @@ class Object
       else
         # Class for auto-generated models to inherit from
         base_model = (::Brick.config.models_inherit_from ||= (begin
-                                                                ::ApplicationRecord
+                                                                Object.const_defined?('ApplicationRecord') ? ::ApplicationRecord : ::ActiveRecord::Base
                                                               rescue StandardError => ex
                                                                 ::ActiveRecord::Base
                                                               end))
@@ -1728,7 +1805,8 @@ class Object
     end
 
     def build_bt_or_hm(full_name, relations, relation, hmts, assoc, inverse_assoc_name, inverse_table, code)
-      singular_table_name = inverse_table&.singularize
+      return unless (singular_table_name = inverse_table&.singularize)
+
       options = {}
       macro = if assoc[:is_bt]
                 # Try to take care of screwy names if this is a belongs_to going to an STI subclass
@@ -2558,8 +2636,9 @@ class Object
                                     assoc_parts[0].downcase! if assoc_parts[0] =~ /^[A-Z0-9_]+$/
                                     assoc_name = assoc_parts.join('.')
                                   else
-                                    class_name_parts = ::Brick.namify(hm_assoc[:inverse_table], :underscore).split('.')
-                                    needs_class = assoc_name.singularize.camelize != class_name_parts.last.singularize.camelize
+                                    last_class_name_part = ::Brick.relations[hm_assoc[:inverse_table]].fetch(:class_name, nil)&.split('::')&.last ||
+                                                           ::Brick.namify(hm_assoc[:inverse_table], :underscore).split('.').last.singularize.camelize
+                                    needs_class = assoc_name.singularize.camelize != last_class_name_part
                                   end
                                   [assoc_name, needs_class]
                                 end
@@ -2592,586 +2671,49 @@ end
 # ==========================================================
 # Get info on all relations during first database connection
 # ==========================================================
+if Object.const_defined?('OTR') && OTR.const_defined?('ActiveRecord')
+  OTR::ActiveRecord.class_exec do
+    class << self
+      alias _brick_establish_connection! establish_connection!
+      def establish_connection!(*args)
+        conn = _brick_establish_connection!(*args)
+        return conn unless ::Brick.config.mode == :on
 
-if ActiveRecord.const_defined?('ConnectionHandling')
-  ActiveRecord::ConnectionHandling
-else
-  ActiveRecord::ConnectionAdapters::ConnectionHandler
-end.class_exec do
-  alias _brick_establish_connection establish_connection
-  def establish_connection(*args)
-    conn = _brick_establish_connection(*args)
-    return conn unless ::Brick.config.mode == :on
-
-    begin
-      # Overwrite SQLite's #begin_db_transaction so it opens in IMMEDIATE mode instead of
-      # the default DEFERRED mode.
-      #   https://discuss.rubyonrails.org/t/failed-write-transaction-upgrades-in-sqlite3/81480/2
-      if ActiveRecord::Base.connection.adapter_name == 'SQLite'
-        arca = ::ActiveRecord::ConnectionAdapters
-        db_statements = arca::SQLite3.const_defined?('DatabaseStatements') ? arca::SQLite3::DatabaseStatements : arca::SQLite3::SchemaStatements
-        # Rails 7.1 and later
-        if arca::AbstractAdapter.private_instance_methods.include?(:with_raw_connection)
-          db_statements.define_method(:begin_db_transaction) do
-            log("begin immediate transaction", "TRANSACTION") do
-              with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
-                conn.transaction(:immediate)
-              end
-            end
-          end
-        else # Rails < 7.1
-          db_statements.define_method(:begin_db_transaction) do
-            log('begin immediate transaction', 'TRANSACTION') { @connection.transaction(:immediate) }
-          end
+        begin
+          # ::Brick.is_db_present = true
+          ::Brick.reflect_tables
+        rescue ActiveRecord::NoDatabaseError
+          # ::Brick.is_db_present = false
         end
+        Module.class_exec &::Brick::ADD_CONST_MISSING
+        conn
       end
-      # ::Brick.is_db_present = true
-      _brick_reflect_tables
-    rescue ActiveRecord::NoDatabaseError
-      # ::Brick.is_db_present = false
     end
-    conn
   end
+else
+  if ActiveRecord.const_defined?('ConnectionHandling')
+    ActiveRecord::ConnectionHandling
+  else
+    ActiveRecord::ConnectionAdapters::ConnectionHandler
+  end.class_exec do
+    alias _brick_establish_connection establish_connection
+    def establish_connection(*args)
+      conn = _brick_establish_connection(*args)
+      return conn unless ::Brick.config.mode == :on
 
-  # This is done separately so that during testing it can be called right after a migration
-  # in order to make sure everything is good.
-  def _brick_reflect_tables
-    return unless ::Brick.config.mode == :on
-
-    # return if ActiveRecord::Base.connection.current_database == 'postgres'
-
-    orig_schema = nil
-    if (relations = ::Brick.relations).keys == [:db_name]
-      ::Brick.remove_instance_variable(:@_additional_references_loaded) if ::Brick.instance_variable_defined?(:@_additional_references_loaded)
-
-      # --------------------------------------------
-      # 1. Load three initializers early
-      #    (inflectsions.rb, brick.rb, apartment.rb)
-      # Very first thing, load inflections since we'll be using .pluralize and .singularize on table and model names
-      if File.exist?(inflections = ::Rails.root&.join('config/initializers/inflections.rb') || '')
-        load inflections
-      end
-      # Now the Brick initializer since there may be important schema things configured
-      if !::Brick.initializer_loaded && File.exist?(brick_initializer = ::Rails.root&.join('config/initializers/brick.rb') || '')
-        ::Brick.initializer_loaded = load brick_initializer
-
-        # After loading the initializer, add compatibility for ActiveStorage and ActionText if those haven't already been
-        # defined.  (Further JSON configuration for ActiveStorage metadata happens later in the after_initialize hook.)
-        ['ActiveStorage', 'ActionText'].each do |ar_extension|
-          if Object.const_defined?(ar_extension) &&
-             (extension = Object.const_get(ar_extension)).respond_to?(:table_name_prefix) &&
-             !::Brick.config.table_name_prefixes.key?(as_tnp = extension.table_name_prefix)
-            ::Brick.config.table_name_prefixes[as_tnp] = ar_extension
-          end
-        end
-
-        # Support the followability gem:  https://github.com/nejdetkadir/followability
-        if Object.const_defined?('Followability') && !::Brick.config.table_name_prefixes.key?('followability_')
-          ::Brick.config.table_name_prefixes['followability_'] = 'Followability'
-        end
-      end
-      # Load the initializer for the Apartment gem a little early so that if .excluded_models and
-      # .default_schema are specified then we can work with non-tenanted models more appropriately
-      if (apartment = Object.const_defined?('Apartment')) &&
-         File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
-        require 'apartment/adapters/abstract_adapter'
-        Apartment::Adapters::AbstractAdapter.class_exec do
-          if instance_methods.include?(:process_excluded_models)
-            def process_excluded_models
-              # All other models will share a connection (at Apartment.connection_class) and we can modify at will
-              Apartment.excluded_models.each do |excluded_model|
-                begin
-                  process_excluded_model(excluded_model)
-                rescue NameError => e
-                  (@bad_models ||= []) << excluded_model
-                end
-              end
-            end
-          end
-        end
-        unless @_apartment_loaded
-          load apartment_initializer
-          @_apartment_loaded = true
-        end
-      end
-      # Only for Postgres  (Doesn't work in sqlite3 or MySQL)
-      # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
-
-      # ---------------------------
-      # 2. Figure out schema things
-      is_postgres = nil
-      is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
-      case ActiveRecord::Base.connection.adapter_name
-      when 'PostgreSQL', 'SQLServer'
-        is_postgres = !is_mssql
-        db_schemas = if is_postgres
-                       ActiveRecord::Base.execute_sql('SELECT nspname AS table_schema, MAX(oid) AS dt FROM pg_namespace GROUP BY 1 ORDER BY 1;')
-                     else
-                       ActiveRecord::Base.execute_sql('SELECT DISTINCT table_schema, NULL AS dt FROM INFORMATION_SCHEMA.tables;')
-                     end
-        ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
-          row = case row
-                when Array
-                  row
-                else
-                  [row['table_schema'], row['dt']]
-                end
-          # Remove any system schemas
-          s[row.first] = { dt: row.last } unless ['information_schema', 'pg_catalog', 'pg_toast', 'heroku_ext',
-                                                  'INFORMATION_SCHEMA', 'sys'].include?(row.first)
-        end
-        possible_schema, possible_schemas, multitenancy = ::Brick.get_possible_schemas
-        if possible_schemas
-          if possible_schema
-            ::Brick.default_schema = ::Brick.apartment_default_tenant
-            schema = possible_schema
-            orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
-            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
-          # When testing, just find the most recently-created schema
-          elsif begin
-                  Rails.env == 'test' ||
-                    ActiveRecord::Base.execute_sql("SELECT value FROM ar_internal_metadata WHERE key='environment';").first&.fetch('value', nil) == 'test'
-                rescue
-                end
-            ::Brick.default_schema = ::Brick.apartment_default_tenant
-            ::Brick.test_schema = schema = ::Brick.db_schemas.to_a.sort { |a, b| b.last[:dt] <=> a.last[:dt] }.first.first
-            if possible_schema.blank?
-              puts "While running tests, using the most recently-created schema, #{schema}."
-            else
-              puts "While running tests, had noticed in the brick.rb initializer that the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\" which does not exist.  Reading table structure from the most recently-created schema, #{schema}."
-            end
-            orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
-            ::Brick.config.schema_behavior = { multitenant: {} } # schema_to_analyse: [schema]
-            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
-          else
-            puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to schema(s) called #{possible_schemas.map { |s| "\"#{s}\"" }.join(', ')}.  No mentioned schema exists. ***"
-            if ::Brick.db_schemas.key?(::Brick.apartment_default_tenant)
-              ::Brick.default_schema = schema = ::Brick.apartment_default_tenant
-            end
-          end
-        end
-      when 'Mysql2', 'Trilogy'
-        ::Brick.default_schema = schema = ActiveRecord::Base.connection.current_database
-      when 'OracleEnhanced'
-        # ActiveRecord::Base.connection.current_database will be something like "XEPDB1"
-        ::Brick.default_schema = schema = ActiveRecord::Base.connection.raw_connection.username
-        ::Brick.db_schemas = {}
-        ActiveRecord::Base.execute_sql("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = {} }
-      when 'SQLite'
-        sql = "SELECT m.name AS relation_name, UPPER(m.type) AS table_type,
-          p.name AS column_name, p.type AS data_type,
-          CASE p.pk WHEN 1 THEN 'PRIMARY KEY' END AS const
-        FROM sqlite_master AS m
-          INNER JOIN pragma_table_info(m.name) AS p
-        WHERE m.name NOT IN ('sqlite_sequence', ?, ?)
-        ORDER BY m.name, p.cid"
-      else
-        puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
-      end
-
-      ::Brick.db_schemas ||= {}
-
-      # ---------------------
-      # 3. Tables and columns
-      # %%% Retrieve internal ActiveRecord table names like this:
-      # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
-      # For if it's not SQLite -- so this is the Postgres and MySQL version
-      measures = []
-      ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
-      case ActiveRecord::Base.connection.adapter_name
-      when 'PostgreSQL', 'SQLite' # These bring back a hash for each row because the query uses column aliases
-        # schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        retrieve_schema_and_tables(sql, is_postgres, is_mssql, schema).each do |r|
-          # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
-          # is the default schema, usually 'public'.
-          schema_name = if ::Brick.config.schema_behavior[:multitenant]
-                          ::Brick.apartment_default_tenant if ::Brick.is_apartment_excluded_table(r['relation_name'])
-                        elsif ![schema, 'public'].include?(r['schema'])
-                          r['schema']
-                        end
-          relation_name = schema_name ? "#{schema_name}.#{r['relation_name']}" : r['relation_name']
-          # Both uppers and lowers as well as underscores?
-          ::Brick.apply_double_underscore_patch if relation_name =~ /[A-Z]/ && relation_name =~ /[a-z]/ && relation_name.index('_')
-          relation = relations[relation_name]
-          relation[:isView] = true if r['table_type'] == 'VIEW'
-          relation[:description] = r['table_description'] if r['table_description']
-          col_name = r['column_name']
-          key = case r['const']
-                when 'PRIMARY KEY'
-                  relation[:pkey][r['key'] || relation_name] ||= []
-                when 'UNIQUE'
-                  relation[:ukeys][r['key'] || "#{relation_name}.#{col_name}"] ||= []
-                  # key = (relation[:ukeys] = Hash.new { |h, k| h[k] = [] }) if key.is_a?(Array)
-                  # key[r['key']]
-                else
-                  if r['data_type'] == 'uuid'
-                    # && r['column_name'] == ::Brick.ar_base.primary_key
-                    # binding.pry
-                    relation[:pkey][r['key'] || relation_name] ||= []
-                  end
-                end
-          # binding.pry if key && r['data_type'] == 'uuid'
-          key << col_name if key
-          cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
-          cols[col_name] = [r['data_type'], r['max_length'], measures&.include?(col_name), r['is_nullable'] == 'NO']
-          # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
-          relation[:col_descrips][col_name] = r['column_description'] if r['column_description']
-        end
-      else # MySQL2, OracleEnhanced, and MSSQL act a little differently, bringing back an array for each row
-        schema_and_tables = case ActiveRecord::Base.connection.adapter_name
-                            when 'OracleEnhanced'
-                              sql =
-"SELECT c.owner AS schema, c.table_name AS relation_name,
-  CASE WHEN v.owner IS NULL THEN 'BASE_TABLE' ELSE 'VIEW' END AS table_type,
-  c.column_name, c.data_type,
-  COALESCE(c.data_length, c.data_precision) AS max_length,
-  CASE ac.constraint_type WHEN 'P' THEN 'PRIMARY KEY' END AS const,
-  ac.constraint_name AS \"key\",
-  CASE c.nullable WHEN 'Y' THEN 'YES' ELSE 'NO' END AS is_nullable
-FROM all_tab_cols c
-  LEFT OUTER JOIN all_cons_columns acc ON acc.owner = c.owner AND acc.table_name = c.table_name AND acc.column_name = c.column_name
-  LEFT OUTER JOIN all_constraints ac ON ac.owner = acc.owner AND ac.table_name = acc.table_name AND ac.constraint_name = acc.constraint_name AND constraint_type = 'P'
-  LEFT OUTER JOIN all_views v ON c.owner = v.owner AND c.table_name = v.view_name
-WHERE c.owner IN (#{::Brick.db_schemas.keys.map { |s| "'#{s}'" }.join(', ')})
-  AND c.table_name NOT IN (?, ?)
-ORDER BY 1, 2, c.internal_column_id, acc.position"
-                              ActiveRecord::Base.execute_sql(sql, *ar_tables)
-                            else
-                              retrieve_schema_and_tables(sql)
-                            end
-
-        schema_and_tables.each do |r|
-          next if r[1].index('$') # Oracle can have goofy table names with $
-
-          if (relation_name = r[1]) =~ /^[A-Z0-9_]+$/
-            relation_name.downcase!
-          # Both uppers and lowers as well as underscores?
-          elsif relation_name =~ /[A-Z]/ && relation_name =~ /[a-z]/ && relation_name.index('_')
-            ::Brick.apply_double_underscore_patch
-          end
-          # Expect the default schema for SQL Server to be 'dbo'.
-          if (::Brick.is_oracle && r[0] != schema) || (is_mssql && r[0] != 'dbo')
-            relation_name = "#{r[0]}.#{relation_name}"
-          end
-
-          relation = relations[relation_name] # here relation represents a table or view from the database
-          relation[:isView] = true if r[2] == 'VIEW' # table_type
-          col_name = ::Brick.is_oracle ? connection.send(:oracle_downcase, r[3]) : r[3]
-          key = case r[6] # constraint type
-                when 'PRIMARY KEY'
-                  # key
-                  relation[:pkey][r[7] || relation_name] ||= []
-                when 'UNIQUE'
-                  relation[:ukeys][r[7] || "#{relation_name}.#{col_name}"] ||= []
-                  # key = (relation[:ukeys] = Hash.new { |h, k| h[k] = [] }) if key.is_a?(Array)
-                  # key[r['key']]
-                end
-          key << col_name if key
-          cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
-          # 'data_type', 'max_length', measure, 'is_nullable'
-          cols[col_name] = [r[4], r[5], measures&.include?(col_name), r[8] == 'NO']
-          # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
-        end
-      end
-
-      # PostGIS adds three views which would confuse Rails if models were to be built for them.
-      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        if relations.key?('geography_columns') && relations.key?('geometry_columns') && relations.key?('spatial_ref_sys')
-          (::Brick.config.exclude_tables ||= []) << 'geography_columns'
-          ::Brick.config.exclude_tables << 'geometry_columns'
-          ::Brick.config.exclude_tables << 'spatial_ref_sys'
-        end
-      end
-
-      # # Add unique OIDs
-      # if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-      #   ActiveRecord::Base.execute_sql(
-      #     "SELECT c.oid, n.nspname, c.relname
-      #     FROM pg_catalog.pg_namespace AS n
-      #       INNER JOIN pg_catalog.pg_class AS c ON n.oid = c.relnamespace
-      #     WHERE c.relkind IN ('r', 'v')"
-      #   ).each do |r|
-      #     next if ['pg_catalog', 'information_schema', ''].include?(r['nspname']) ||
-      #       ['ar_internal_metadata', 'schema_migrations'].include?(r['relname'])
-      #     relation = relations.fetch(r['relname'], nil)
-      #     if relation
-      #       (relation[:oid] ||= {})[r['nspname']] = r['oid']
-      #     else
-      #       puts "Where is #{r['nspname']} #{r['relname']} ?"
-      #     end
-      #   end
-      # end
-      # schema = ::Brick.default_schema # Reset back for this next round of fun
-
-      # ---------------------------------------------
-      # 4. Foreign key info
-      # (done in two parts which get JOINed together in Ruby code)
-      kcus = nil
-      entry_type = nil
-      case ActiveRecord::Base.connection.adapter_name
-      when 'PostgreSQL', 'Mysql2', 'Trilogy', 'SQLServer'
-        # Part 1 -- all KCUs
-        sql = "SELECT CONSTRAINT_CATALOG, CONSTRAINT_SCHEMA, CONSTRAINT_NAME, ORDINAL_POSITION,
-                      TABLE_NAME, COLUMN_NAME
-              FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE#{"
-              WHERE CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }#{"
-              WHERE CONSTRAINT_SCHEMA = '#{ActiveRecord::Base.connection.current_database&.tr("'", "''")}'" if is_mysql
-              }"
-        kcus = ActiveRecord::Base.execute_sql(sql).each_with_object({}) do |v, s|
-                 if (entry_type ||= v.is_a?(Array) ? :array : :hash) == :hash
-                   key = "#{v['constraint_name']}.#{v['constraint_schema']}.#{v['constraint_catalog']}.#{v['ordinal_position']}"
-                   key << ".#{v['table_name']}.#{v['column_name']}" unless is_postgres || is_mssql
-                   s[key] = [v['constraint_schema'], v['table_name']]
-                 else # Array
-                   key = "#{v[2]}.#{v[1]}.#{v[0]}.#{v[3]}"
-                   key << ".#{v[4]}.#{v[5]}" unless is_postgres || is_mssql
-                   s[key] = [v[1], v[4]]
-                 end
-               end
-
-        # Part 2 -- fk_references
-        sql = "SELECT kcu.CONSTRAINT_SCHEMA, kcu.TABLE_NAME, kcu.COLUMN_NAME,
-            #{# These will get filled in with real values (effectively doing the JOIN in Ruby)
-              is_postgres || is_mssql ? 'NULL as primary_schema, NULL as primary_table' :
-                                        'kcu.REFERENCED_TABLE_NAME, kcu.REFERENCED_COLUMN_NAME'},
-            kcu.CONSTRAINT_NAME AS CONSTRAINT_SCHEMA_FK,
-            rc.UNIQUE_CONSTRAINT_NAME, rc.UNIQUE_CONSTRAINT_SCHEMA, rc.UNIQUE_CONSTRAINT_CATALOG, kcu.ORDINAL_POSITION
-          FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
-            INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu
-              ON kcu.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG
-              AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
-              AND kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME#{"
-          WHERE kcu.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema}#{"
-          WHERE kcu.CONSTRAINT_SCHEMA = '#{ActiveRecord::Base.connection.current_database&.tr("'", "''")}'" if is_mysql}"
-        fk_references = ActiveRecord::Base.execute_sql(sql)
-      when 'SQLite'
-        sql = "SELECT NULL AS constraint_schema, m.name, fkl.\"from\", NULL AS primary_schema, fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
-        FROM sqlite_master m
-          INNER JOIN pragma_foreign_key_list(m.name) fkl ON m.type = 'table'
-        ORDER BY m.name, fkl.seq"
-        fk_references = ActiveRecord::Base.execute_sql(sql)
-      when 'OracleEnhanced'
-        schemas = ::Brick.db_schemas.keys.map { |s| "'#{s}'" }.join(', ')
-        sql =
-        "SELECT -- fk
-               ac.owner AS constraint_schema, acc_fk.table_name, acc_fk.column_name,
-               -- referenced pk
-               ac.r_owner AS primary_schema, acc_pk.table_name AS primary_table, acc_fk.constraint_name AS constraint_schema_fk
-               -- , acc_pk.column_name
-        FROM all_cons_columns acc_fk
-          INNER JOIN all_constraints ac ON acc_fk.owner = ac.owner
-            AND acc_fk.constraint_name = ac.constraint_name
-          INNER JOIN all_cons_columns acc_pk ON ac.r_owner = acc_pk.owner
-            AND ac.r_constraint_name = acc_pk.constraint_name
-        WHERE ac.constraint_type = 'R'
-          AND ac.owner IN (#{schemas})
-          AND ac.r_owner IN (#{schemas})"
-        fk_references = ActiveRecord::Base.execute_sql(sql)
-      end
-      ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
-      # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-      ::Brick.default_schema ||= 'public' if is_postgres
-      fk_references&.each do |fk|
-        fk = fk.values unless fk.is_a?(Array)
-        # Virtually JOIN KCUs to fk_references in order to fill in the primary schema and primary table
-        kcu_key = "#{fk[6]}.#{fk[7]}.#{fk[8]}.#{fk[9]}"
-        kcu_key << ".#{fk[3]}.#{fk[4]}" unless is_postgres || is_mssql
-        if (kcu = kcus&.fetch(kcu_key, nil))
-          fk[3] = kcu[0]
-          fk[4] = kcu[1]
-        end
-        # Multitenancy makes things a little more general overall, except for non-tenanted tables
-        if ::Brick.is_apartment_excluded_table(::Brick.namify(fk[1]))
-          fk[0] = ::Brick.apartment_default_tenant
-        elsif (is_postgres && (fk[0] == 'public' || (multitenancy && fk[0] == schema))) ||
-              (::Brick.is_oracle && fk[0] == schema) ||
-              (is_mssql && fk[0] == 'dbo') ||
-              (!is_postgres && !::Brick.is_oracle && !is_mssql && ['mysql', 'performance_schema', 'sys'].exclude?(fk[0]))
-          fk[0] = nil
-        end
-        if ::Brick.is_apartment_excluded_table(fk[4])
-          fk[3] = ::Brick.apartment_default_tenant
-        elsif (is_postgres && (fk[3] == 'public' || (multitenancy && fk[3] == schema))) ||
-              (::Brick.is_oracle && fk[3] == schema) ||
-              (is_mssql && fk[3] == 'dbo') ||
-              (!is_postgres && !::Brick.is_oracle && !is_mssql && ['mysql', 'performance_schema', 'sys'].exclude?(fk[3]))
-          fk[3] = nil
-        end
-        if ::Brick.is_oracle
-          fk[1].downcase! if fk[1] =~ /^[A-Z0-9_]+$/
-          fk[4].downcase! if fk[4] =~ /^[A-Z0-9_]+$/
-          fk[2] = connection.send(:oracle_downcase, fk[2])
-        end
-        ::Brick._add_bt_and_hm(fk, relations)
-      end
-      kcus = nil # Allow this large item to be garbage collected
-    end
-
-    table_name_lookup = (::Brick.table_name_lookup ||= {})
-    relations.each do |k, v|
-      next if k.is_a?(Symbol)
-
-      rel_name = k.split('.').map { |rel_part| ::Brick.namify(rel_part, :underscore) }
-      schema_names = rel_name[0..-2]
-      schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == ::Brick.apartment_default_tenant
-      v[:schema] = schema_names.join('.') unless schema_names.empty?
-      # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
-      if (singular = rel_name.last.singularize).blank?
-        singular = rel_name.last
-      end
-      name_parts = if (tnp = ::Brick.config.table_name_prefixes
-                                    &.find { |k1, _v1| singular.start_with?(k1) && singular.length > k1.length }
-                      ).present?
-                     v[:auto_prefixed_schema] = tnp.first
-                     # v[:resource] = rel_name.last[tnp.first.length..-1]
-                     [tnp.last, singular[tnp.first.length..-1]]
-                   else
-                     # v[:resource] = rel_name.last
-                     [singular]
-                   end
-      proposed_name_parts = (schema_names + name_parts).map { |p| ::Brick.namify(p, :underscore).camelize }
-      # Find out if the proposed name leads to a module or class that already exists and is not an AR class
-      colliding_thing = nil
-      loop do
-        klass = Object
-        proposed_name_parts.each do |part|
-          if klass.const_defined?(part)
-            klass = klass.const_get(part)
-          else
-            klass = nil
-            break
-          end
-        end
-        break if !klass || (klass < ActiveRecord::Base) # Break if all good -- no conflicts
-
-        # Find a unique name since there's already something that's non-AR with that same name
-        last_idx = proposed_name_parts.length - 1
-        proposed_name_parts[last_idx] = ::Brick.ensure_unique(proposed_name_parts[last_idx], 'X')
-        colliding_thing ||= klass
-      end
-      v[:class_name] = proposed_name_parts.join('::')
-      # Was:  v[:resource] = v[:class_name].underscore.tr('/', '.')
-      v[:resource] = proposed_name_parts.last.underscore
-      if colliding_thing
-        message_start = if colliding_thing.is_a?(Module) && Object.const_defined?(:Rails) &&
-                           colliding_thing.constants.find { |c| colliding_thing.const_get(c) < Rails::Application }
-                          "The module for the Rails application itself, \"#{colliding_thing.name}\","
-                        else
-                          "Non-AR #{colliding_thing.class.name.downcase} \"#{colliding_thing.name}\""
-                        end
-        puts "WARNING:  #{message_start} already exists.\n  Will set up to auto-create model #{v[:class_name]} for table #{k}."
+      begin
+        # ::Brick.is_db_present = true
+        ::Brick.reflect_tables
+      rescue ActiveRecord::NoDatabaseError
+        # ::Brick.is_db_present = false
       end
-      # Track anything that's out-of-the-ordinary
-      table_name_lookup[v[:class_name]] = k unless v[:class_name].underscore.pluralize == k
-    end
-    ::Brick.load_additional_references if ::Brick.initializer_loaded
-
-    if is_postgres
-      params = []
-      ActiveRecord::Base.execute_sql("-- inherited and partitioned tables counts
-      SELECT n.nspname, parent.relname,
-        ((SUM(child.reltuples::float) / greatest(SUM(child.relpages), 1))) *
-        (SUM(pg_relation_size(child.oid))::float / (current_setting('block_size')::float))::integer AS rowcount
-      FROM pg_inherits
-        INNER JOIN pg_class parent ON pg_inherits.inhparent = parent.oid
-        INNER JOIN pg_class child ON pg_inherits.inhrelid = child.oid
-        INNER JOIN pg_catalog.pg_namespace n ON n.oid = parent.relnamespace#{
-    if schema
-      params << schema
-      "
-      WHERE n.nspname = COALESCE(?, 'public')"
-    end}
-      GROUP BY n.nspname, parent.relname, child.reltuples, child.relpages, child.oid
-
-      UNION ALL
-
-      -- table count
-      SELECT n.nspname, pg_class.relname,
-        (pg_class.reltuples::float / greatest(pg_class.relpages, 1)) *
-          (pg_relation_size(pg_class.oid)::float / (current_setting('block_size')::float))::integer AS rowcount
-      FROM pg_class
-        INNER JOIN pg_catalog.pg_namespace n ON n.oid = pg_class.relnamespace#{
-    if schema
-      params << schema
-      "
-      WHERE n.nspname = COALESCE(?, 'public')"
-    end}
-      GROUP BY n.nspname, pg_class.relname, pg_class.reltuples, pg_class.relpages, pg_class.oid", params).each do |tblcount|
-        # %%% What is the default schema here?
-        prefix = "#{tblcount['nspname']}." unless tblcount['nspname'] == (schema || 'public')
-        relations.fetch("#{prefix}#{tblcount['relname']}", nil)&.[]=(:rowcount, tblcount['rowcount'].to_i.round)
+      if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace)
+        Module.class_exec &::Brick::ADD_CONST_MISSING
       end
+      conn
     end
-
-    if orig_schema && (orig_schema = (orig_schema - ['pg_catalog', 'pg_toast', 'heroku_ext']).first)
-      puts "Now switching back to \"#{orig_schema}\" schema."
-      ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", orig_schema)
-    end
-  end
-
-  def retrieve_schema_and_tables(sql = nil, is_postgres = nil, is_mssql = nil, schema = nil)
-    is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer' if is_mssql.nil?
-    params = ar_tables
-    sql ||= "SELECT t.table_schema AS \"schema\", t.table_name AS relation_name, t.table_type,#{"
-      pg_catalog.obj_description(
-        ('\"' || t.table_schema || '\".\"' || t.table_name || '\"')::regclass::oid, 'pg_class'
-      ) AS table_description,
-      pg_catalog.col_description(
-        ('\"' || t.table_schema || '\".\"' || t.table_name || '\"')::regclass::oid, c.ordinal_position
-      ) AS column_description," if is_postgres}
-      c.column_name, #{is_postgres ? "CASE c.data_type WHEN 'USER-DEFINED' THEN pg_t.typname ELSE c.data_type END AS data_type" : 'c.data_type'},
-      COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
-      kcu.constraint_type AS const, kcu.constraint_name AS \"key\",
-      c.is_nullable
-    FROM INFORMATION_SCHEMA.tables AS t
-      LEFT OUTER JOIN INFORMATION_SCHEMA.columns AS c ON t.table_schema = c.table_schema
-        AND t.table_name = c.table_name
-        LEFT OUTER JOIN
-        (SELECT kcu1.constraint_schema, kcu1.table_name, kcu1.column_name, kcu1.ordinal_position,
-        tc.constraint_type, kcu1.constraint_name
-        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu1
-        INNER JOIN INFORMATION_SCHEMA.table_constraints AS tc
-          ON kcu1.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
-          AND kcu1.TABLE_NAME = tc.TABLE_NAME
-          AND kcu1.CONSTRAINT_NAME = tc.constraint_name
-          AND tc.constraint_type != 'FOREIGN KEY' -- For MSSQL
-        ) AS kcu ON
-        -- kcu.CONSTRAINT_CATALOG = t.table_catalog AND
-        kcu.CONSTRAINT_SCHEMA = c.table_schema
-        AND kcu.TABLE_NAME = c.table_name
-        AND kcu.column_name = c.column_name#{"
-    --    AND kcu.position_in_unique_constraint IS NULL" unless is_mssql}#{"
-      INNER JOIN pg_catalog.pg_namespace pg_n ON pg_n.nspname = t.table_schema
-      INNER JOIN pg_catalog.pg_class pg_c ON pg_n.oid = pg_c.relnamespace AND pg_c.relname = c.table_name
-      INNER JOIN pg_catalog.pg_attribute pg_a ON pg_c.oid = pg_a.attrelid AND pg_a.attname = c.column_name
-      INNER JOIN pg_catalog.pg_type pg_t ON pg_t.oid = pg_a.atttypid" if is_postgres}
-    WHERE t.table_schema #{is_postgres || is_mssql ?
-        "NOT IN ('information_schema', 'pg_catalog', 'pg_toast', 'heroku_ext',
-                 'INFORMATION_SCHEMA', 'sys')"
-        :
-        "= '#{ActiveRecord::Base.connection.current_database&.tr("'", "''")}'"}#{
-    if is_postgres && schema
-      params = params.unshift(schema) # Used to use this SQL:  current_setting('SEARCH_PATH')
-      "
-      AND t.table_schema = COALESCE(?, 'public')"
-    end}
-  --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
-      AND t.table_name NOT IN ('pg_stat_statements', ?, ?)
-    ORDER BY 1, t.table_type DESC, 2, c.ordinal_position"
-    ActiveRecord::Base.execute_sql(sql, *params)
-  end
-
-  def ar_tables
-    ar_smtn = if ActiveRecord::Base.respond_to?(:schema_migrations_table_name)
-                ActiveRecord::Base.schema_migrations_table_name
-              else
-                'schema_migrations'
-              end
-    ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : 'ar_internal_metadata'
-    [ar_smtn, ar_imtn]
   end
 end
-
 # ==========================================
 
 # :nodoc:
@@ -3464,7 +3006,7 @@ module Brick
       end
     end
 
-    def _brick_index(tbl_name, mode = nil, separator = nil, relation = nil)
+    def _brick_index(tbl_name, mode = nil, separator = nil, relation = nil, not_path = nil)
       separator ||= '_'
       res_name = (tbl_name_parts = tbl_name.split('.'))[0..-2].first
       res_name << '.' if res_name
@@ -3472,22 +3014,28 @@ module Brick
 
       res_parts = ((mode == :singular) ? res_name.singularize : res_name).split('.')
       res_parts.shift if ::Brick.apartment_multitenant && res_parts.length > 1 && res_parts.first == ::Brick.apartment_default_tenant
+      index2 = []
+      if ::Brick.config.path_prefix
+        res_parts.unshift(::Brick.config.path_prefix)
+        index2 << ::Brick.config.path_prefix
+      end
       if (aps = relation&.fetch(:auto_prefixed_schema, nil)) # && res_parts.last.start_with?(aps)
         aps = aps[0..-2] if aps[-1] == '_'
         last_part = res_parts.last # [aps.length..-1]
         res_parts[-1] = aps
         res_parts << last_part
-      end
-      path_prefix = []
-      if ::Brick.config.path_prefix
-        res_parts.unshift(::Brick.config.path_prefix)
-        path_prefix << ::Brick.config.path_prefix
+        index2 << aps
       end
       index = res_parts.map(&:underscore).join(separator)
-      index = index.tr('_', 'x') if separator == 'x'
-      # Rails applies an _index suffix to that route when the resource name isn't something plural
-      index << '_index' if mode != :singular && separator == '_' &&
-                           index == (path_prefix + [relation[:class_name]&.underscore&.tr('/', '_') || '_']).join(separator)
+      if separator == 'x'
+        index = index.tr('_', 'x')
+      else
+        # Rails applies an _index suffix to that route when the resource name isn't something plural
+        index << '_index' if mode != :singular && !not_path &&
+                             index == (
+                                        index2 + [relation[:class_name][(relation&.fetch(:auto_prefixed_class, nil)&.length&.+ 2) || 0..-1]&.underscore&.tr('/', '_') || '_']
+                                      ).join(separator)
+      end
       index
     end