brick 1.0.71 → 1.0.72

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e50dce8dd2821ec196836393569138d4e18c53a9ef1e3e910ddffa6bc3788824
-  data.tar.gz: 982b26f7ed3a14f69589b6c422b37a5ec42b210c095cf85ef0eeab151ea80c59
+  metadata.gz: 06c3efed47ee7086f01a4f59c177f362343f376b1d6534f86e61ee38001b0d7b
+  data.tar.gz: 8b521c56eb5afc09b06aec0adf0085136cb9e94d2c1a93355a8a2fc79da0316b
 SHA512:
-  metadata.gz: 2c0e76b3e092d35f57045f3dd106ae9b8c90b266df0a7c0c973824ed20c1ac41560f124420d164e4e9d170b9a386345f424f19bce01bf041c9ebb553c842e553
-  data.tar.gz: 6d257bbec4c364456be5167b55c2eb377d94cdd0485e56dfb699daf14f3dce7a46c94c91534ecbe9c8f090b564e8752de0c3b88cf7560e01ca9d8388a3ec9930
+  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
@@ -146,11 +147,8 @@ module ActiveRecord
             dsl2 << 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
+        ::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
@@ -323,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 = '')
@@ -361,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)
@@ -387,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.
@@ -429,22 +428,7 @@ module ActiveRecord
       if selects&.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
         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 +436,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 +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')
@@ -751,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))
@@ -1386,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
@@ -1443,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') &&
@@ -1487,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'
@@ -1538,15 +1536,21 @@ 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!
           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 +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
@@ -1612,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
@@ -1633,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,#{"
@@ -1705,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 }
@@ -1750,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

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 71
+    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_]+$/
@@ -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.71
+  version: 1.0.72
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-16 00:00:00.000000000 Z
+date: 2022-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord