brick 1.0.71 → 1.0.73

data/lib/brick/extensions.rb

@@ -68,13 +68,14 @@ module ActiveRecord
     end
 
     def self._brick_primary_key(relation = nil)
-      return instance_variable_get(:@_brick_primary_key) if instance_variable_defined?(:@_brick_primary_key)
+      return @_brick_primary_key if instance_variable_defined?(:@_brick_primary_key)
 
       pk = begin
              primary_key.is_a?(String) ? [primary_key] : primary_key || []
            rescue
              []
            end
+      pk.map! { |pk_part| pk_part =~ /^[A-Z0-9_]+$/ ? pk_part.downcase : pk_part } unless connection.adapter_name == 'MySQL2'
       # Just return [] if we're missing any part of the primary key.  (PK is usually just "id")
       if relation && pk.present?
         @_brick_primary_key ||= pk.any? { |pk_part| !relation[:cols].key?(pk_part) } ? [] : pk
@@ -106,7 +107,8 @@ module ActiveRecord
       bracket_name = nil
       prefix = [prefix] unless prefix.is_a?(Array)
       if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
-        dsl2 = +''
+        dsl2 = +'' # To replace our own DSL definition in case it needs to be expanded
+        dsl3 = +'' # To return expanded DSL that is nested from another model
         klass = nil
         dsl.each_char do |ch|
           if bracket_name
@@ -128,11 +130,16 @@ module ActiveRecord
               end
               if klass.column_names.exclude?(parts.last) &&
                  (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
+                # Expand this entry which refers to an association name
                 members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, true)
                 members += members2
                 dsl2 << dsl2a
+                dsl3 << dsl2a
               else
                 dsl2 << "[#{bracket_name}]"
+                if emit_dsl
+                  dsl3 << "[#{prefix[1..-1].map { |p| "#{p.to_s}." }.join if prefix.length > 1}#{bracket_name}]"
+                end
                 members << parts
               end
               bracket_name = nil
@@ -144,18 +151,22 @@ module ActiveRecord
             klass = self
           else
             dsl2 << ch
+            dsl3 << ch
           end
         end
-        # Rewrite the DSL just in case it's different because we had to expand it
-        unless emit_dsl
-          # puts "Compare:\n  #{dsl}\n  #{dsl2}"
-          ::Brick.config.model_descrips[name] = dsl2
-        end
+        # Rewrite the DSL in case it's now different from having to expand it
+        # if ::Brick.config.model_descrips[name] != dsl2
+        #   puts ::Brick.config.model_descrips[name]
+        #   puts dsl2.inspect
+        #   puts dsl3.inspect
+        #   binding.pry
+        # end
+        ::Brick.config.model_descrips[name] = dsl2 unless emit_dsl
       else # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
         x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
         x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
       end
-      emit_dsl ? [members, dsl2] : members
+      emit_dsl ? [members, dsl3] : members
     end
 
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
@@ -223,13 +234,21 @@ module ActiveRecord
     end
 
     def self.bt_link(assoc_name)
-      model_underscore = name.underscore
       assoc_name = CGI.escapeHTML(assoc_name.to_s)
-      model_path = Rails.application.routes.url_helpers.send("#{model_underscore.tr('/', '_').pluralize}_path".to_sym)
+      model_path = Rails.application.routes.url_helpers.send("#{_brick_index}_path".to_sym)
       av_class = Class.new.extend(ActionView::Helpers::UrlHelper)
       av_class.extend(ActionView::Helpers::TagHelper) if ActionView.version < ::Gem::Version.new('7')
       link = av_class.link_to(name, model_path)
-      model_underscore == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
+      table_name == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
+    end
+
+    def self._brick_index
+      tbl_parts = table_name.split('.')
+      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.first == Apartment.default_schema
+      if (index = tbl_parts.map(&:underscore).join('_')) == index.singularize
+        index << '_index' # Rails applies an _index suffix to that route when the resource name is singular
+      end
+      index
     end
 
     def self.brick_import_template
@@ -323,7 +342,7 @@ module ActiveRecord
   end
 
   class Relation
-    attr_reader :_brick_chains
+    attr_reader :_brick_chains, :_arel_applied_aliases
 
     # CLASS STUFF
     def _recurse_arel(piece, prefix = '')
@@ -361,7 +380,7 @@ module ActiveRecord
           # parent = piece.left == on.left.relation ? on.right.relation : on.left.relation
           # binding.pry if piece.left.is_a?(Arel::Nodes::TableAlias)
           if table.is_a?(Arel::Nodes::TableAlias)
-            alias_name = table.right
+            @_arel_applied_aliases << (alias_name = table.right)
             table = table.left
           end
           (_brick_chains[table._arel_table_type] ||= []) << (alias_name || table.table_alias || table.name)
@@ -387,6 +406,7 @@ module ActiveRecord
 
     # INSTANCE STUFF
     def _arel_alias_names
+      @_arel_applied_aliases = []
       # %%% If with Rails 3.1 and older you get "NoMethodError: undefined method `eq' for nil:NilClass"
       # when trying to call relation.arel, then somewhere along the line while navigating a has_many
       # relationship it can't find the proper foreign key.
@@ -408,7 +428,7 @@ module ActiveRecord
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
-        next if ['_brick_schema', '_brick_order'].include?(k)
+        next if ['_brick_schema', '_brick_order', 'controller', 'action'].include?(k)
 
         case (ks = k.split('.')).length
         when 1
@@ -428,23 +448,11 @@ module ActiveRecord
       # %%% Skip the metadata columns
       if selects&.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
+        # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
+        #     ActiveRecord::StatementInvalid (TinyTds::Error: DBPROCESS is dead or not enabled)
+        #     Relevant info here:  https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/402
         columns.each do |col|
-          if (col_name = col.name) == 'class'
-            col_alias = " AS #{col.name}_"
-          else
-            alias_name = nil
-            idx = 0
-            col_name.each_char do |c|
-              unless (c >= 'a' && c <= 'z') ||
-                 c == '_' ||
-                 (c >= 'A' && c <= 'Z') ||
-                 (c >= '0' && c <= '9')
-                (alias_name ||= col_name.dup)[idx] = 'x'
-              end
-              ++idx
-            end
-            col_alias = " AS #{alias_name}" if alias_name
-          end
+          col_alias = " AS #{col.name}_" if (col_name = col.name) == 'class'
           selects << if is_mysql
                        "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
                      elsif is_postgres || is_mssql
@@ -452,8 +460,8 @@ module ActiveRecord
                        cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col_name)&.first&.start_with?('xml')
                        "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
                      elsif col.type # Could be Sqlite or Oracle
-                       if col_alias
-                         "#{tbl_no_schema}.#{col_name}#{col_alias}"
+                       if col_alias || !(/^[a-z0-9_]+$/ =~ col_name)
+                         "#{tbl_no_schema}.\"#{col_name}\"#{col_alias}"
                        else
                          "#{tbl_no_schema}.#{col_name}"
                        end
@@ -478,9 +486,14 @@ module ActiveRecord
             next if chains[k1].nil?
 
             tbl_name = (field_tbl_names[v.first][k1] ||= shift_or_first(chains[k1])).split('.').last
+            # If it's Oracle, quote any AREL aliases that had been applied
+            tbl_name = "\"#{tbl_name}\"" if ::Brick.is_oracle && rel_dupe._arel_applied_aliases.include?(tbl_name)
             field_tbl_name = nil
             v1.map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
+              # binding.pry if chains[sel_col.first].nil?
               field_tbl_name = (field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])).split('.').last
+              # If it's Oracle, quote any AREL aliases that had been applied
+              field_tbl_name = "\"#{field_tbl_name}\"" if ::Brick.is_oracle && rel_dupe._arel_applied_aliases.include?(field_tbl_name)
 
               # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
               is_xml = is_distinct && Brick.relations[sel_col.first.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
@@ -737,7 +750,8 @@ Module.class_exec do
                # Vabc instead of VABC)
                full_class_name = +''
                full_class_name << "::#{self.name}" unless self == Object
-               full_class_name << "::#{plural_class_name.underscore.singularize.camelize}"
+               singular_class_name = ::Brick.namify(plural_class_name, :underscore).singularize.camelize
+               full_class_name << "::#{singular_class_name}"
                if plural_class_name == 'BrickSwagger' ||
                   (
                     (::Brick.config.add_status || ::Brick.config.add_orphans) &&
@@ -751,9 +765,11 @@ Module.class_exec do
                    base_module == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
                    (schema_name = [(singular_table_name = class_name.underscore),
                                    (table_name = singular_table_name.pluralize),
-                                   class_name,
+                                   ::Brick.is_oracle ? class_name.upcase : class_name,
                                    (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas.include?(s) }&.camelize ||
                                   (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name))
+               return self.const_get(schema_name) if self.const_defined?(schema_name)
+
                # Build out a module for the schema if it's namespaced
                # schema_name = schema_name.camelize
                base_module.const_set(schema_name.to_sym, (built_module = Module.new))
@@ -1120,64 +1136,63 @@ class Object
           end
           return [new_controller_class, code + "end # BrickGem controller\n"]
         when 'BrickSwagger'
-          is_swagger = true # if request.format == :json)
+          is_swagger = true
         end
 
         self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
-          # We do all of this now so that bt_descrip and hm_counts are available on the model early in case the user
-          # wants to do an ORDER BY based on any of that
-          translations = {}
-          join_array = ::Brick::JoinArray.new
-          is_add_bts = is_add_hms = true
-          # This builds out bt_descrip and hm_counts on the model
-          model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
-
           if is_swagger
-            json = { 'openapi': '3.0.1', 'info': { 'title': 'API V1', 'version': 'v1' },
+            if !params&.key?('_brick_schema') &&
+              (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
+              if params
+                referrer_params.each { |k, v| params.send(:parameters)[k] = v }
+              else
+                api_params = referrer_params&.to_h
+              end
+            end
+            ::Brick.set_db_schema(params || api_params)
+            json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
                      'servers': [
-                       { 'url': 'https://{defaultHost}', 'variables': { 'defaultHost': { 'default': 'www.example.com' } } }
+                       { 'url': '{scheme}://{defaultHost}', 'variables': {
+                         'scheme': { 'default': request.env['rack.url_scheme'] },
+                         'defaultHost': { 'default': request.env['HTTP_HOST'] }
+                       } }
                      ]
                    }
-            json['paths'] = relations.inject({}) do |s, v|
-              s["/api/v1/#{v.first}"] = {
-                'get': {
-                  'summary': "list #{v.first}",
-                  'parameters': v.last[:cols].map { |k, v| { 'name' => k, 'schema': { 'type': v.first } } },
-                  'responses': { '200': { 'description': 'successful' } }
-                }
-              }
-              # next if v.last[:isView]
-
-              s["/api/v1/#{v.first}/{id}"] = {
-                'patch': {
-                  'summary': "update a #{v.first.singularize}",
-                  'parameters': v.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
-                    { 'name' => k, 'schema': { 'type': v.first } }
-                  end,
-                  'responses': { '200': { 'description': 'successful' } }
+            json['paths'] = relations.inject({}) do |s, relation|
+              unless ::Brick.config.enable_api == false
+                table_description = relation.last[:description]
+                s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}"] = {
+                  'get': {
+                    'summary': "list #{relation.first}",
+                    'description': table_description,
+                    'parameters': relation.last[:cols].map do |k, v|
+                                    param = { 'name' => k, 'schema': { 'type': v.first } }
+                                    if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                                      param['description'] = col_descrip
+                                    end
+                                    param
+                                  end,
+                    'responses': { '200': { 'description': 'successful' } }
+                  }
                 }
-                # "/api/v1/books/{id}": {
-                #   "parameters": [
-                #     {
-                #       "name": "id",
-                #       "in": "path",
-                #       "description": "id",
-                #       "required": true,
-                #       "schema": {
-                #         "type": "string"
-                #       }
-                #     },
-                #     {
-                #       "name": "Authorization",
-                #       "in": "header",
-                #       "schema": {
-                #         "type": "string"
-                #       }
-                #     }
-                #   ],
-              }
-              s
+
+                s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}/{id}"] = {
+                  'patch': {
+                    'summary': "update a #{relation.first.singularize}",
+                    'description': table_description,
+                    'parameters': relation.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
+                      param = { 'name' => k, 'schema': { 'type': v.first } }
+                      if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                        param['description'] = col_descrip
+                      end
+                      param
+                    end,
+                    'responses': { '200': { 'description': 'successful' } }
+                  }
+                } unless relation.last.fetch(:isView, nil)
+                s
+              end
             end
             render inline: json.to_json, content_type: request.format
             return
@@ -1185,6 +1200,14 @@ class Object
 
           # Normal (non-swagger) request
 
+          # We do all of this now so that bt_descrip and hm_counts are available on the model early in case the user
+          # wants to do an ORDER BY based on any of that
+          translations = {}
+          join_array = ::Brick::JoinArray.new
+          is_add_bts = is_add_hms = true
+          # This builds out bt_descrip and hm_counts on the model
+          model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+
           # %%% Allow params to define which columns to use for order_by
           # Overriding the default by providing a querystring param?
           ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
@@ -1198,8 +1221,9 @@ class Object
             end
             render inline: exported_csv, content_type: request.format
             return
-          elsif request.format == :js # Asking for JSON?
-            render inline: model.df_export(model.brick_import_template).to_json, content_type: request.format
+          elsif request.format == :js || request.path.start_with?('/api/') # Asking for JSON?
+            data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
+            render inline: data.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
             return
           end
 
@@ -1215,7 +1239,7 @@ class Object
                    "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
                  end
           end
-          instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
+          instance_variable_set("@#{table_name.pluralize}".to_sym, ar_relation.dup._select!(*selects, *counts))
           if namespace && (idx = lookup_context.prefixes.index(table_name))
             lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
           end
@@ -1230,32 +1254,34 @@ class Object
           @_brick_erd = params['_brick_erd']&.to_i
         end
 
-        _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk))
-        code << "  def index\n"
-        code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
-        code << "    @#{table_name}.brick_select(params)\n"
-        code << "  end\n"
-
-        is_pk_string = nil
-        if (pk_col = model&.primary_key)
-          code << "  def show\n"
-          code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
+        unless is_swagger
+          ::Brick.set_db_schema
+          _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk)) if pk
+          code << "  def index\n"
+          code << "    @#{table_name.pluralize} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
+          code << "    @#{table_name.pluralize}.brick_select(params)\n"
           code << "  end\n"
-          self.define_method :show do
-            ::Brick.set_db_schema(params)
-            id = if model.columns_hash[pk_col]&.type == :string
-                   is_pk_string = true
-                   params[:id]
-                 else
-                   params[:id]&.split(/[\/,_]/)
-                 end
-            id = id.first if id.is_a?(Array) && id.length == 1
-            instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+
+          is_pk_string = nil
+          if pk.present?
+            code << "  def show\n"
+            code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
+            code << "  end\n"
+            self.define_method :show do
+              ::Brick.set_db_schema(params)
+              id = if model.columns_hash[pk.first]&.type == :string
+                     is_pk_string = true
+                     params[:id]
+                   else
+                     params[:id]&.split(/[\/,_]/)
+                   end
+              id = id.first if id.is_a?(Array) && id.length == 1
+              instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+            end
           end
-        end
 
-        # By default, views get marked as read-only
-        # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
+          # By default, views get marked as read-only
+          # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
           code << "  def new\n"
           code << "    @#{singular_table_name} = #{model.name}.new\n"
           code << "  end\n"
@@ -1289,7 +1315,7 @@ class Object
             end
           end
 
-          if pk_col
+          if pk.present?
             # if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
             #   ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
             # end
@@ -1336,9 +1362,9 @@ class Object
             end
           end
 
-          code << "private\n" if pk_col || is_need_params
+          code << "private\n" if pk.present? || is_need_params
 
-          if pk_col
+          if pk.present?
             code << "  def find_#{singular_table_name}
     id = params[:id]&.split(/[\\/,_]/)
     @#{singular_table_name} = #{model.name}.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
@@ -1366,16 +1392,16 @@ class Object
             private params_name
             # Get column names for params from relations[model.table_name][:cols].keys
           end
-        # end
+        end # unless is_swagger
         code << "end # #{namespace_name}#{class_name}\n"
       end # class definition
       [built_controller, code]
     end
 
     def _brick_get_hm_assoc_name(relation, hm_assoc, source = nil)
-      if (relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1) &&
+      if (relation[:hm_counts][hm_assoc[:inverse_table]]&.> 1) &&
          hm_assoc[:alternate_name] != (source || name.underscore)
-        plural = ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])
+        plural = "#{hm_assoc[:assoc_name]}_#{ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])}"
         new_alt_name = (hm_assoc[:alternate_name] == name.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
         # uniq = 1
         # while same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }
@@ -1386,8 +1412,13 @@ class Object
         [new_alt_name, true]
       else
         assoc_name = ::Brick.namify(hm_assoc[:inverse_table]).pluralize
+        if (needs_class = assoc_name.include?('.')) # If there is a schema name present, use a downcased version for the :has_many
+          assoc_parts = assoc_name.split('.')
+          assoc_parts[0].downcase! if assoc_parts[0] =~ /^[A-Z0-9_]+$/
+          assoc_name = assoc_parts.join('.')
+        end
         # hm_assoc[:assoc_name] = assoc_name
-        [assoc_name, assoc_name.include?('.')]
+        [assoc_name, needs_class]
       end
     end
   end
@@ -1443,7 +1474,8 @@ module ActiveRecord::ConnectionHandling
                   row['table_schema']
                 end
           # Remove any system schemas
-          s[row] = nil unless ['information_schema', 'pg_catalog'].include?(row)
+          s[row] = nil unless ['information_schema', 'pg_catalog',
+                               'INFORMATION_SCHEMA', 'sys'].include?(row)
         end
         if (is_multitenant = (multitenancy = ::Brick.config.schema_behavior[:multitenant]) &&
            (sta = multitenancy[:schema_to_analyse]) != 'public') &&
@@ -1487,6 +1519,7 @@ module ActiveRecord::ConnectionHandling
       # 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'
@@ -1499,6 +1532,8 @@ module ActiveRecord::ConnectionHandling
                           r['schema']
                         end
           relation_name = schema_name ? "#{schema_name}.#{r['relation_name']}" : r['relation_name']
+          # Both uppers and lowers as well as underscores?
+          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']
@@ -1515,6 +1550,7 @@ module ActiveRecord::ConnectionHandling
           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 and OracleEnhanced act a little differently, bringing back an array for each row
         schema_and_tables = case ActiveRecord::Base.connection.adapter_name
@@ -1538,15 +1574,24 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
                             else
                               ActiveRecord::Base.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-Z_]+$/
+          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('_')
+            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 = r[3]
+          col_name = ::Brick.is_oracle ? connection.send(:oracle_downcase, r[3]) : r[3]
           key = case r[6] # constraint type
                 when 'PRIMARY KEY'
                   # key
@@ -1558,8 +1603,8 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
                 end
           key << col_name if key
           cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
-          # 'data_type', 'max_length'
-          cols[col_name] = [r[4], r[5], measures&.include?(col_name)]
+          # '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
@@ -1612,10 +1657,10 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         schemas = ::Brick.db_schemas.keys.map { |s| "'#{s}'" }.join(', ')
         sql =
         "SELECT -- fk
-               ac.owner AS constraint_schema, acc_fk.table_name, LOWER(acc_fk.column_name),
+               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
-               -- , LOWER(acc_pk.column_name)
+               -- , 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
@@ -1633,55 +1678,80 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         # Multitenancy makes things a little more general overall, except for non-tenanted tables
         if apartment_excluded&.include?(::Brick.namify(fk[1]).singularize.camelize)
           fk[0] = Apartment.default_schema
-        elsif is_postgres && (fk[0] == 'public' || (is_multitenant && fk[0] == schema)) ||
-              !is_postgres && ['mysql', 'performance_schema', 'sys'].exclude?(fk[0])
+        elsif (is_postgres && (fk[0] == 'public' || (is_multitenant && 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 apartment_excluded&.include?(fk[4].singularize.camelize)
           fk[3] = Apartment.default_schema
-        elsif is_postgres && (fk[3] == 'public' || (is_multitenant && fk[3] == schema)) ||
-              !is_postgres && ['mysql', 'performance_schema', 'sys'].exclude?(fk[3])
+        elsif (is_postgres && (fk[3] == 'public' || (is_multitenant && 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
-        fk[1].downcase! if ::Brick.is_oracle && fk[1] =~ /^[A-Z_]+$/
-        fk[4].downcase! if ::Brick.is_oracle && fk[4] =~ /^[A-Z_]+$/
+        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
     end
 
     tables = []
     views = []
+    table_class_length = 0
+    view_class_length = 0
     relations.each do |k, v|
       name_parts = k.split('.')
       idx = 1
       name_parts = name_parts.map do |x|
-        ((idx += 1) < name_parts.length ? x.singularize : x).camelize
+        (idx += 1) <= name_parts.length ? x : x.singularize
       end
+      name_parts.shift if apartment && name_parts.length > 1 && name_parts.first == Apartment.default_schema
+      class_name = name_parts.map(&:camelize).join('::')
       if v.key?(:isView)
+        view_class_length = class_name.length if class_name.length > view_class_length
         views
       else
-        name_parts.shift if apartment && name_parts.length > 1 && name_parts.first == Apartment.default_schema
+        table_class_length = class_name.length if class_name.length > table_class_length
         tables
-      end << name_parts.join('::')
+      end << [class_name, name_parts]
     end
-    unless tables.empty?
-      puts "\nClasses that can be built from tables:"
-      tables.sort.each { |x| puts x }
+    puts "\n" if tables.present? || views.present?
+    if tables.present?
+      puts "Classes that can be built from tables:"
+      display_classes(tables, table_class_length)
     end
-    unless views.empty?
-      puts "\nClasses that can be built from views:"
-      views.sort.each { |x| puts x }
+    if views.present?
+      puts "Classes that can be built from views:"
+      display_classes(views, view_class_length)
     end
 
     ::Brick.load_additional_references if initializer_loaded
   end
 
+  def display_classes(rels, max_length)
+    rels.sort.each do |rel|
+      rel_link = rel.last.dup.map(&:underscore)
+      rel_link[-1] = rel_link[-1]
+      puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{rel_link.join('/')}"
+    end
+    puts "\n"
+  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?
     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, 'pg_class'
-      ) AS table_description," if is_postgres}
+        ('\"' || 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, c.data_type,
       COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
       kcu.constraint_type AS const, kcu.constraint_name AS \"key\",
@@ -1705,7 +1775,8 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
     --    AND kcu.position_in_unique_constraint IS NULL" unless is_mssql}
         AND kcu.ordinal_position = c.ordinal_position
     WHERE t.table_schema #{is_postgres || is_mssql ?
-        "NOT IN ('information_schema', 'pg_catalog')"
+        "NOT IN ('information_schema', 'pg_catalog',
+                 'INFORMATION_SCHEMA', 'sys')"
         :
         "= '#{ActiveRecord::Base.connection.current_database.tr("'", "''")}'"}#{"
       AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }
@@ -1724,6 +1795,43 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
     ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : ''
     [ar_smtn, ar_imtn]
   end
+
+  def apply_double_underscore_patch
+    unless @double_underscore_applied
+      # Same as normal #camelize and #underscore, just that double-underscores turn into a single underscore
+      ActiveSupport::Inflector.class_eval do
+        def camelize(term, uppercase_first_letter = true)
+          strings = term.to_s.split('__').map do |string|
+            # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
+            if !uppercase_first_letter || uppercase_first_letter == :lower
+              string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase! || match }
+            else
+              string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
+            end
+            string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+              word = $2
+              substituted = inflections.acronyms[word] || word.capitalize! || word
+              $1 ? "::#{substituted}" : substituted
+            end
+            string
+          end
+          strings.join('_')
+        end
+
+        def underscore(camel_cased_word)
+          return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
+          camel_cased_word.to_s.gsub("::", "/").split('_').map do |word|
+            word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
+            word.gsub!(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
+            word.tr!("-", "_")
+            word.downcase!
+            word
+          end.join('__')
+        end
+      end
+      @double_underscore_applied = true
+    end
+  end
 end
 
 # ==========================================
@@ -1750,7 +1858,7 @@ module Brick
 
   class << self
     def _add_bt_and_hm(fk, relations, is_polymorphic = false, is_optional = false)
-      bt_assoc_name = ::Brick.namify(fk[2])
+      bt_assoc_name = ::Brick.namify(fk[2], :downcase)
       unless is_polymorphic
         bt_assoc_name = if bt_assoc_name.underscore.end_with?('_id')
                           bt_assoc_name[-3] == '_' ? bt_assoc_name[0..-4] : bt_assoc_name[0..-3]
@@ -1851,6 +1959,11 @@ module Brick
 
       return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[1] == exclusion[0] && fk[2] == exclusion[1] && primary_table == exclusion[2] } || hms.nil?
 
+      # if fk[1].end_with?('Suppliers') && fk[4] == 'People'
+      #   puts fk.inspect
+      #   binding.pry
+      # end
+
       if (assoc_hm = hms.fetch((hm_cnstr_name = "hm_#{cnstr_name}"), nil))
         if assoc_hm[:fk].is_a?(String)
           assoc_hm[:fk] = [assoc_hm[:fk], fk[2]] unless fk[2] == assoc_hm[:fk]
@@ -1858,7 +1971,6 @@ module Brick
           assoc_hm[:fk] << fk[2]
         end
         assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
-        assoc_hm[:inverse] = assoc_bt
       else
         inv_tbl = if ::Brick.config.schema_behavior[:multitenant] && apartment && fk[0] == Apartment.default_schema
                     for_tbl
@@ -1869,7 +1981,7 @@ module Brick
                                           inverse_table: inv_tbl, inverse: assoc_bt }
         assoc_hm[:polymorphic] = true if is_polymorphic
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
-        hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1
+        this_hm_count = hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1
       end
       assoc_bt[:inverse] = assoc_hm
     end