brick 1.0.70 → 1.0.72

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af28a866a39817e9daa3a54b8f091c790d9280571cec94f9a3a317606e239fd9
-  data.tar.gz: a2cfe0b823c8b364c8f842852e631a48efe7f9dde8d506a27fbc85ebb74e58eb
+  metadata.gz: 06c3efed47ee7086f01a4f59c177f362343f376b1d6534f86e61ee38001b0d7b
+  data.tar.gz: 8b521c56eb5afc09b06aec0adf0085136cb9e94d2c1a93355a8a2fc79da0316b
 SHA512:
-  metadata.gz: 0cc18926c7c449e7dfba8d919d41b2490cb4d4a14692073f98f96903da075a31ff029f7a5f5931a845c7caf8f00b51cdba9ab0711dfa626d9e445d9122350b2b
-  data.tar.gz: 84373ca68edb9ebb88b8ccf2963bbf2e416c35c41840df1c1cd6922ef757cac204453aeb1e15881316681558a53ce17e32692e16320bb1b53c608bc41401920d
+  metadata.gz: 1566ddaa89e45496b752b64ec218456e05dca50cc81a722d5a88e4d4bbe19b28ca981eeb253688f44e55a8ef9949d195bdc5a61f5ba7980b2507c315277b4d4d
+  data.tar.gz: 7643f78bf92721c89bdb0065f112592cba26023ea7745ba34551ce39d9378cd286f50b3ea1491c813e10f6d93521ef16c54fa70edc5dbcd4d70cb5ad6a859ad3

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
@@ -99,13 +100,14 @@ module ActiveRecord
       dsl
     end
 
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false)
+    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, emit_dsl = false, is_polymorphic = false)
       build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
       build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
       members = []
       bracket_name = nil
       prefix = [prefix] unless prefix.is_a?(Array)
       if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
+        dsl2 = +''
         klass = nil
         dsl.each_char do |ch|
           if bracket_name
@@ -125,7 +127,15 @@ module ActiveRecord
                 end
                 translations[parts[0..-2].join('.')] = klass
               end
-              members << parts
+              if klass.column_names.exclude?(parts.last) &&
+                 (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
+                members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, true)
+                members += members2
+                dsl2 << dsl2a
+              else
+                dsl2 << "[#{bracket_name}]"
+                members << parts
+              end
               bracket_name = nil
             else
               bracket_name << ch
@@ -133,13 +143,17 @@ module ActiveRecord
           elsif ch == '['
             bracket_name = +''
             klass = self
+          else
+            dsl2 << ch
           end
         end
+        # Rewrite the DSL in case it's now different from having to expand it
+        ::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
-      members
+      emit_dsl ? [members, dsl2] : members
     end
 
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
@@ -169,9 +183,12 @@ module ActiveRecord
                           this_obj = caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
                           break if this_obj.nil?
                         end
+                        if this_obj.is_a?(ActiveRecord::Base) && (obj_descrip = this_obj.class.brick_descrip(this_obj))
+                          this_obj = obj_descrip
+                        end
                         this_obj&.to_s || ''
                       end
-              is_brackets_have_content = true unless (datum).blank?
+              is_brackets_have_content = true unless datum.blank?
               output << (datum || '')
               bracket_name = nil
             else
@@ -244,7 +261,8 @@ module ActiveRecord
 
         # join_array will receive this relation name when calling #brick_parse_dsl
         _br_bt_descrip[bt.first] = if bt[1].is_a?(Array)
-                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
+                                     # Last two params here:  "false" is for don't emit DSL, and "true" is for yes, we are polymorphic
+                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, false, true) }
                                    else
                                      { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
                                    end
@@ -303,7 +321,7 @@ module ActiveRecord
   end
 
   class Relation
-    attr_reader :_brick_chains
+    attr_reader :_brick_chains, :_arel_applied_aliases
 
     # CLASS STUFF
     def _recurse_arel(piece, prefix = '')
@@ -341,7 +359,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)
@@ -367,6 +385,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.
@@ -414,10 +433,17 @@ module ActiveRecord
                        "`#{tbl_no_schema}`.`#{col_name}`#{col_alias}"
                      elsif is_postgres || is_mssql
                        # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
-                       cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col.name)&.first&.start_with?('xml')
+                       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}"
-                     else # Sqlite or Oracle
-                       "#{tbl_no_schema}.#{col_name}#{col_alias}"
+                     elsif col.type # Could be Sqlite or Oracle
+                       if col_alias || !(/^[a-z0-9_]+$/ =~ col_name)
+                         "#{tbl_no_schema}.\"#{col_name}\"#{col_alias}"
+                       else
+                         "#{tbl_no_schema}.#{col_name}"
+                       end
+                     else # Oracle with a custom data type
+                       typ = col.sql_type
+                       "'<#{typ.end_with?('_TYP') ? typ[0..-5] : typ}>' AS #{col.name}"
                      end
         end
       end
@@ -436,9 +462,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')
@@ -709,9 +740,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))
@@ -1344,8 +1377,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
@@ -1401,7 +1439,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') &&
@@ -1415,7 +1454,7 @@ module ActiveRecord::ConnectionHandling
         # ActiveRecord::Base.connection.current_database will be something like "XEPDB1"
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.raw_connection.username
         ::Brick.db_schemas = {}
-        execute_oracle("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = nil }
+        ActiveRecord::Base.execute_sql("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = nil }
       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,
@@ -1445,6 +1484,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'
@@ -1478,8 +1518,9 @@ module ActiveRecord::ConnectionHandling
         schema_and_tables = case ActiveRecord::Base.connection.adapter_name
                             when 'OracleEnhanced'
                               sql =
-"SELECT c.owner AS schema, c.table_name AS relation_name, 'BASE_TABLE' AS table_type,
-  LOWER(c.column_name) AS column_name, c.data_type,
+"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\",
@@ -1487,21 +1528,29 @@ module ActiveRecord::ConnectionHandling
 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"
-                              execute_oracle(sql, *ar_tables)
+                              ActiveRecord::Base.execute_sql(sql, *ar_tables)
                             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!
           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
@@ -1513,8 +1562,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
@@ -1567,10 +1616,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
@@ -1579,7 +1628,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         WHERE ac.constraint_type = 'R'
           AND ac.owner IN (#{schemas})
           AND ac.r_owner IN (#{schemas})"
-        fk_references = ActiveRecord::Base.execute_oracle(sql)
+        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'
@@ -1588,49 +1637,71 @@ 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].pluralize
+      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,#{"
@@ -1660,7 +1731,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 }
@@ -1679,16 +1751,6 @@ 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 execute_oracle(*sql_args)
-    cursor = ActiveRecord::Base.execute_sql(*sql_args)
-    result = []
-    while row = cursor.fetch()
-      result << row
-    end
-    cursor.close
-    result
-  end
 end
 
 # ==========================================
@@ -1715,7 +1777,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], true)
       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]

data/lib/brick/frameworks/rails/engine.rb

@@ -87,9 +87,9 @@ module Brick
 
             def path_keys(hm_assoc, fk_name, obj_name, pk)
               keys = if fk_name.is_a?(Array) && pk.is_a?(Array) # Composite keys?
-                       fk_name.zip(pk.map { |pk_part| "#{obj_name}.#{pk_part}" })
+                       fk_name.zip(pk.map { |fk_part| "#{obj_name}.#{fk_part}" })
                      else
-                       pk = pk.each_with_object([]) { |pk_part, s| s << "#{obj_name}.#{pk_part}" }
+                       pk = pk.map { |pk_part| "#{obj_name}.#{pk_part}" }
                        [[fk_name, pk.length == 1 ? pk.first : pk.inspect]]
                      end
               keys << [hm_assoc.inverse_of.foreign_type, hm_assoc.active_record.name] if hm_assoc.options.key?(:as)
@@ -106,8 +106,8 @@ module Brick
                 return _brick_find_template(*args, **options)
               end
 
-            if @_brick_model
-                pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(model_name, nil))
+              if @_brick_model
+                pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(@_brick_model&.table_name, nil))
                 obj_name = model_name.split('::').last.underscore
                 path_obj_name = model_name.underscore.tr('/', '_')
                 table_name = obj_name.pluralize
@@ -1090,9 +1090,9 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
       mermaid.initialize({
         startOnLoad: true,
         securityLevel: \"loose\",
+        er: { useMaxWidth: false },
         mermaid: {callback: function(objId) {
           var svg = document.getElementById(objId);
-          svg.removeAttribute(\"width\");
           var cb;
           for(cb in cbs) {
             var gErd = svg.getElementById(cb);

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 70
+    TINY = 72
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/brick.rb

@@ -152,7 +152,8 @@ module Brick
     end
 
     # Convert spaces to underscores if the second character and onwards is mixed case
-    def namify(name)
+    def namify(name, attempt_downcase = false)
+      name.downcase! if attempt_downcase && name =~ /^[A-Z0-9_]+$/
       if name.include?(' ')
         # All uppers or all lowers?
         if name[1..-1] =~ /^[A-Z0-9_]+$/ || name[1..-1] =~ /^[a-z0-9_]+$/
@@ -560,7 +561,7 @@ ActiveSupport.on_load(:active_record) do
         class << self
           def execute_sql(sql, *param_array)
             param_array = param_array.first if param_array.length == 1 && param_array.first.is_a?(Array)
-            if ActiveRecord::Base.connection.adapter_name == 'SQLServer'
+            if ['OracleEnhanced', 'SQLServer'].include?(ActiveRecord::Base.connection.adapter_name)
               connection.exec_query(send(:sanitize_sql_array, [sql] + param_array)).rows
             else
               connection.execute(send(:sanitize_sql_array, [sql] + param_array))
@@ -726,6 +727,63 @@ ActiveSupport.on_load(:active_record) do
         end
       end
     end
+
+    # Migration stuff
+    module ConnectionAdapters
+      # Override the downcasing implementation from the OracleEnhanced gem as it has bad regex
+      if const_defined?(:OracleEnhanced)
+        module OracleEnhanced::Quoting
+          private
+
+          def oracle_downcase(column_name)
+            return nil if column_name.nil?
+
+            /^[A-Za-z0-9_]+$/ =~ column_name ? column_name.downcase : column_name
+          end
+        end
+      end
+      if const_defined?(:SQLServerAdapter)
+        class SQLServer::TableDefinition
+          alias _brick_new_column_definition new_column_definition
+          def new_column_definition(name, type, **options)
+            case type
+            when :serial
+              type = :integer
+              options[:is_identity] = true
+            when :bigserial
+              type = :bigint
+              options[:is_identity] = true
+            end
+            _brick_new_column_definition(name, type, **options)
+          end
+          def serial(*args)
+            options = args.extract_options!
+            options[:is_identity] = true
+            args.each { |name| column(name, 'integer', options) }
+          end
+          def bigserial(*args)
+            options = args.extract_options!
+            options[:is_identity] = true
+            args.each { |name| column(name, 'bigint', options) }
+          end
+          # Seems that geography gets used a fair bit in MSSQL
+          def geography(*args)
+            options = args.extract_options!
+            # options[:precision] ||= 8
+            # options[:scale] ||= 2
+            args.each { |name| column(name, 'geography', options) }
+          end
+        end
+        class SQLServerAdapter
+          unless respond_to?(:schema_exists?)
+            def schema_exists?(schema)
+              schema_sql = 'SELECT 1 FROM sys.schemas WHERE name = ?'
+              ActiveRecord::Base.execute_sql(schema_sql, schema).present?
+            end
+          end
+        end
+      end
+    end
   end
   # rubocop:enable Lint/ConstantDefinitionInBlock
 

data/lib/generators/brick/migrations_generator.rb

@@ -23,6 +23,21 @@ module Brick
                   'time with time zone' => 'time',
                   'double precision' => 'float',
                   'smallint' => 'integer', # %%% Need to put in "limit: 2"
+                  # # Oracle data types
+                  'VARCHAR2' => 'string',
+                  'CHAR' => 'string',
+                  ['NUMBER', 22] => 'integer',
+                  /^INTERVAL / => 'string', # Time interval stuff like INTERVAL YEAR(2) TO MONTH, INTERVAL '999' DAY(3), etc
+                  'XMLTYPE' => 'xml',
+                  'RAW' => 'binary',
+                  'SDO_GEOMETRY' => 'geometry',
+                  # MSSQL data types
+                  'int' => 'integer',
+                  'nvarchar' => 'string',
+                  'nchar' => 'string',
+                  'datetime2' => 'timestamp',
+                  'bit' => 'boolean',
+                  'varbinary' => 'binary',
                   # Sqlite data types
                   'TEXT' => 'text',
                   '' => 'string',
@@ -122,7 +137,7 @@ module Brick
         fringe.each do |tbl|
           next unless (relation = ::Brick.relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
 
-          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ActiveRecord::Base.primary_key].flatten)
+          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ApplicationRecord.primary_key].flatten.sort)
           # In case things aren't as standard
           if pkey_cols.empty?
             pkey_cols = if rpk.empty? && relation[:cols][arpk.first]&.first == key_type
@@ -141,7 +156,7 @@ module Brick
                    end
           unless schema.blank? || built_schemas.key?(schema)
             mig = +"  def change\n    create_schema(:#{schema}) unless schema_exists?(:#{schema})\n  end\n"
-            migration_file_write(mig_path, "create_db_schema_#{schema}", current_mig_time += 1.minute, ar_version, mig)
+            migration_file_write(mig_path, "create_db_schema_#{schema.underscore}", current_mig_time += 1.minute, ar_version, mig)
             built_schemas[schema] = nil
           end
 
@@ -151,11 +166,16 @@ module Brick
           # a column definition which includes :primary_key -- %%% also using a data type of bigserial or serial
           # if this one has come in as bigint or integer.
           pk_is_also_fk = fkey_cols.any? { |assoc| pkey_cols&.first == assoc[:fk] } ? pkey_cols&.first : nil
-          # Support missing primary key (by adding:  ,id: false)
+          # Support missing primary key (by adding:  , id: false)
           id_option = if pk_is_also_fk || !pkey_cols&.present?
+                        needs_serial_col = true
                         ', id: false'
-                      elsif ((pkey_col_first = relation[:cols][pkey_cols&.first]&.first) &&
-                             (pkey_col_first = SQL_TYPES[pkey_col_first] || pkey_col_first) != key_type)
+                      elsif ((pkey_col_first = (col_def = relation[:cols][pkey_cols&.first])&.first) &&
+                             (pkey_col_first = SQL_TYPES[pkey_col_first] || SQL_TYPES[col_def&.[](0..1)] ||
+                                               SQL_TYPES.find { |r| r.first.is_a?(Regexp) && pkey_col_first =~ r.first }&.last ||
+                                               pkey_col_first
+                             ) != key_type
+                            )
                         case pkey_col_first
                         when 'integer'
                           ', id: :serial'
@@ -164,9 +184,14 @@ module Brick
                         else
                           ", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
                         end +
-                          (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '') +
-                          (!is_4x_rails && (comment = relation&.fetch(:description, nil))&.present? ? ", comment: #{comment.inspect}" : '')
+                          (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '')
                       end
+          if !id_option && pkey_cols.sort != arpk
+            id_option = ", primary_key: :#{pkey_cols.first}"
+          end
+          if !is_4x_rails && (comment = relation&.fetch(:description, nil))&.present?
+            (id_option ||= +'') << ", comment: #{comment.inspect}"
+          end
           # Find the ActiveRecord class in order to see if the columns have comments
           unless is_4x_rails
             klass = begin
@@ -187,18 +212,24 @@ module Brick
           possible_ts = [] # Track possible generic timestamps
           add_fks = [] # Track foreign keys to add after table creation
           relation[:cols].each do |col, col_type|
-            sql_type = SQL_TYPES[col_type.first] || col_type.first
-            suffix = col_type[3] ? +', null: false' : +''
+            sql_type = SQL_TYPES[col_type.first] || SQL_TYPES[col_type[0..1]] ||
+                       SQL_TYPES.find { |r| r.first.is_a?(Regexp) && col_type.first =~ r.first }&.last ||
+                       col_type.first
+            suffix = col_type[3] || pkey_cols&.include?(col) ? +', null: false' : +''
             if !is_4x_rails && klass && (comment = klass.columns_hash.fetch(col, nil)&.comment)&.present?
               suffix << ", comment: #{comment.inspect}"
             end
             # Determine if this column is used as part of a foreign key
-            if fk = fkey_cols.find { |assoc| col == assoc[:fk] }
+            if (fk = fkey_cols.find { |assoc| col == assoc[:fk] })
               to_table = fk[:inverse_table].split('.')
               to_table = to_table.length == 1 ? ":#{to_table.first}" : "'#{fk[:inverse_table]}'"
+              if needs_serial_col && pkey_cols&.include?(col) && (new_serial_type = {'integer' => 'serial', 'bigint' => 'bigserial'}[sql_type])
+                sql_type = new_serial_type
+                needs_serial_col = false
+              end
               if fk[:fk] != "#{fk[:assoc_name].singularize}_id" # Need to do our own foreign_key tricks, not use references?
                 column = fk[:fk]
-                mig << "      t.#{sql_type} :#{column}#{suffix}\n"
+                mig << emit_column(sql_type, column, suffix)
                 add_fks << [to_table, column, ::Brick.relations[fk[:inverse_table]]]
               else
                 suffix << ", type: :#{sql_type}" unless sql_type == key_type

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.70
+  version: 1.0.72
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-13 00:00:00.000000000 Z
+date: 2022-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord