activerecord-jdbc-alt-adapter 61.0.0-java → 70.0.0.rc1-java

data/lib/arjdbc/mssql/schema_definitions.rb

@@ -14,80 +14,95 @@ module ActiveRecord
 
         # datetime with seconds always zero (:00) and without fractional seconds
         def smalldatetime(*args, **options)
-          args.each { |name| column(name, :smalldatetime, options) }
+          args.each { |name| column(name, :smalldatetime, **options) }
         end
 
         # this is the old sql server datetime type, the precision is as follow
         # xx1, xx3, and xx7
         def datetime_basic(*args, **options)
-          args.each { |name| column(name, :datetime_basic, options) }
+          args.each { |name| column(name, :datetime_basic, **options) }
         end
 
         def real(*args, **options)
-          args.each { |name| column(name, :real, options) }
+          args.each { |name| column(name, :real, **options) }
         end
 
         def money(*args, **options)
-          args.each { |name| column(name, :money, options) }
+          args.each { |name| column(name, :money, **options) }
         end
 
         def smallmoney(*args, **options)
-          args.each { |name| column(name, :smallmoney, options) }
+          args.each { |name| column(name, :smallmoney, **options) }
         end
 
         def char(*args, **options)
-          args.each { |name| column(name, :char, options) }
+          args.each { |name| column(name, :char, **options) }
         end
 
         def varchar(*args, **options)
-          args.each { |name| column(name, :varchar, options) }
+          args.each { |name| column(name, :varchar, **options) }
         end
 
         def varchar_max(*args, **options)
-          args.each { |name| column(name, :varchar_max, options) }
+          args.each { |name| column(name, :varchar_max, **options) }
         end
 
         def text_basic(*args, **options)
-          args.each { |name| column(name, :text_basic, options) }
+          args.each { |name| column(name, :text_basic, **options) }
         end
 
         def nchar(*args, **options)
-          args.each { |name| column(name, :nchar, options) }
+          args.each { |name| column(name, :nchar, **options) }
         end
 
         def ntext(*args, **options)
-          args.each { |name| column(name, :ntext, options) }
+          args.each { |name| column(name, :ntext, **options) }
         end
 
         def binary_basic(*args, **options)
-          args.each { |name| column(name, :binary_basic, options) }
+          args.each { |name| column(name, :binary_basic, **options) }
         end
 
         def varbinary(*args, **options)
-          args.each { |name| column(name, :varbinary, options) }
+          args.each { |name| column(name, :varbinary, **options) }
         end
 
         def uuid(*args, **options)
-          args.each { |name| column(name, :uniqueidentifier, options) }
+          args.each { |name| column(name, :uniqueidentifier, **options) }
         end
       end
 
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
+        def column(name, type, index: nil, **options)
+          # TODO: remove this when the below changed is released
+          #   Fix erroneous nil default precision on virtual datetime columns #46110
+          #   https://github.com/rails/rails/pull/46110
+          #
+          if @conn.supports_datetime_with_precision?
+            if type == :datetime && !options.key?(:precision)
+              options[:precision] = 7
+            end
+          end
+
+          super
+        end
+
+
         def new_column_definition(name, type, **options)
           case type
           when :primary_key
             options[:is_identity] = true
+          when :datetime
+            options[:precision] = 7 if !options.key?(:precision) && @conn.supports_datetime_with_precision?
           end
 
           super
         end
 
         def timestamps(**options)
-          if !options.key?(:precision) && @conn.supports_datetime_with_precision?
-            options[:precision] = 7
-          end
+          options[:precision] = 7 if !options.key?(:precision) && @conn.supports_datetime_with_precision?
 
           super
         end

data/lib/arjdbc/mssql/schema_dumper.rb

@@ -28,11 +28,23 @@ module ActiveRecord
           super && column.identity?
         end
 
+        def schema_precision(column)
+          case column.type
+          when :datetime
+            if column.precision == 7
+              nil
+            else
+              column.precision.inspect
+            end
+          else
+            super
+          end
+        end
+
         # def schema_collation(column)
         #   return unless column.collation
         #   column.collation if column.collation != collation
         # end
-
       end
     end
   end

data/lib/arjdbc/mssql/schema_statements.rb

@@ -7,36 +7,36 @@ module ActiveRecord
 
         NATIVE_DATABASE_TYPES = {
           # Logical Rails types to SQL Server types
-          primary_key:   'bigint NOT NULL IDENTITY(1,1) PRIMARY KEY',
-          integer:       { name: 'int', limit: 4 },
-          boolean:       { name: 'bit' },
-          decimal:       { name: 'decimal' },
-          float:         { name: 'float' },
-          date:          { name: 'date' },
-          time:          { name: 'time' },
-          datetime:      { name: 'datetime2' },
-          string:        { name: 'nvarchar', limit: 4000 },
-          text:          { name: 'nvarchar(max)' },
-          binary:        { name: 'varbinary(max)' },
+          primary_key:    'bigint NOT NULL IDENTITY(1,1) PRIMARY KEY',
+          integer:        { name: 'int', limit: 4 },
+          boolean:        { name: 'bit' },
+          decimal:        { name: 'decimal' },
+          float:          { name: 'float' },
+          date:           { name: 'date' },
+          time:           { name: 'time' },
+          datetime:       { name: 'datetime2' },
+          string:         { name: 'nvarchar', limit: 4000 },
+          text:           { name: 'nvarchar(max)' },
+          binary:         { name: 'varbinary(max)' },
           # Other types or SQL Server specific
-          bigint:        { name: 'bigint' },
-          smalldatetime: { name: 'smalldatetime' },
+          bigint:         { name: 'bigint' },
+          smalldatetime:  { name: 'smalldatetime' },
           datetime_basic: { name: 'datetime' },
-          timestamp:     { name: 'datetime' },
-          real:          { name: 'real' },
-          money:         { name: 'money' },
-          smallmoney:    { name: 'smallmoney' },
-          char:          { name: 'char' },
-          nchar:         { name: 'nchar' },
-          varchar:       { name: 'varchar', limit: 8000 },
-          varchar_max:   { name: 'varchar(max)' },
-          uuid:          { name: 'uniqueidentifier' },
-          binary_basic:  { name: 'binary' },
-          varbinary:     { name: 'varbinary', limit: 8000 },
+          timestamp:      { name: 'datetime' },
+          real:           { name: 'real' },
+          money:          { name: 'money' },
+          smallmoney:     { name: 'smallmoney' },
+          char:           { name: 'char' },
+          nchar:          { name: 'nchar' },
+          varchar:        { name: 'varchar', limit: 8000 },
+          varchar_max:    { name: 'varchar(max)' },
+          uuid:           { name: 'uniqueidentifier' },
+          binary_basic:   { name: 'binary' },
+          varbinary:      { name: 'varbinary', limit: 8000 },
           # Deprecated SQL Server types
-          image:         { name: 'image' },
-          ntext:         { name: 'ntext' },
-          text_basic:    { name: 'text' }
+          image:          { name: 'image' },
+          ntext:          { name: 'ntext' },
+          text_basic:     { name: 'text' }
         }.freeze
 
         def native_database_types
@@ -127,9 +127,17 @@ module ActiveRecord
           create_database(name, options)
         end
 
-        def remove_column(table_name, column_name, type = nil, options = {})
-          raise ArgumentError.new('You must specify at least one column name.  Example: remove_column(:people, :first_name)') if column_name.is_a? Array
+        def remove_columns(table_name, *column_names, type: nil, **options)
+          if column_names.empty?
+            raise ArgumentError.new('You must specify at least one column name. Example: remove_columns(:people, :first_name)')
+          end
+
+          column_names.each do |column_name|
+            remove_column(table_name, column_name, type, **options)
+          end
+        end
 
+        def remove_column(table_name, column_name, _type = nil, **options)
           return if options[:if_exists] == true && !column_exists?(table_name, column_name)
 
           remove_check_constraints(table_name, column_name)
@@ -138,7 +146,7 @@ module ActiveRecord
           execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
         end
 
-        def drop_table(table_name, options = {})
+        def drop_table(table_name, **options)
           # mssql cannot recreate referenced table with force: :cascade
           # https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-table-transact-sql?view=sql-server-2017
           if options[:force] == :cascade
@@ -248,7 +256,7 @@ module ActiveRecord
           (order_columns << super).join(', ')
         end
 
-        def add_timestamps(table_name, options = {})
+        def add_timestamps(table_name, **options)
           if !options.key?(:precision) && supports_datetime_with_precision?
             options[:precision] = 7
           end
@@ -256,6 +264,16 @@ module ActiveRecord
           super
         end
 
+        def add_column(table_name, column_name, type, **options)
+          if supports_datetime_with_precision?
+            if type == :datetime && !options.key?(:precision)
+              options[:precision] = 7
+            end
+          end
+
+          super
+        end
+
         def create_schema_dumper(options)
           MSSQL::SchemaDumper.create(self, options)
         end
@@ -323,16 +341,20 @@ module ActiveRecord
           quoted_table = quote_table_name(table_name)
           quoted_column = quote_column_name(column_name)
           quoted_default = quote(default)
+
           unless null || default.nil?
             execute("UPDATE #{quoted_table} SET #{quoted_column}=#{quoted_default} WHERE #{quoted_column} IS NULL")
           end
+
+          options = { limit: column.limit, precision: column.precision, scale: column.scale }
+
           sql_alter = [
             "ALTER TABLE #{quoted_table}",
-            "ALTER COLUMN #{quoted_column} #{type_to_sql(column.type, limit: column.limit, precision: column.precision, scale: column.scale)}",
-            (' NOT NULL' unless null)
+            "ALTER COLUMN #{quoted_column} #{type_to_sql(column.type, **options)}",
+            ('NOT NULL' unless null)
           ]
 
-          execute(sql_alter.join(' '))
+          execute(sql_alter.compact.join(' '))
         end
 
         def update_table_definition(table_name, base) #:nodoc:
@@ -345,11 +367,14 @@ module ActiveRecord
           MSSQL::SchemaCreation.new(self)
         end
 
-        def create_table_definition(*args)
-          MSSQL::TableDefinition.new(self, *args)
+        def create_table_definition(name, **options)
+          MSSQL::TableDefinition.new(self, name, **options)
         end
 
         def new_column_from_field(table_name, field)
+          # NOTE: this method is used by the columns method in the abstract Class
+          # to map column_definitions. It would be good if column_definitions is
+          # implemented in ruby
           field
         end
 

data/lib/arjdbc/mssql/transaction.rb

@@ -27,10 +27,10 @@ module ActiveRecord
       module RealTransactionExt
         attr_reader :initial_transaction_isolation
 
-        def initialize(connection, options, *args)
+        def initialize(connection, isolation: nil, joinable: true, run_commit_callbacks: false)
           @connection = connection
 
-          if options[:isolation]
+          if isolation
             @initial_transaction_isolation = current_transaction_isolation
           end
 

data/lib/arjdbc/mssql/types/date_and_time_types.rb

@@ -13,9 +13,9 @@ module ActiveRecord
             return %("#{value}") if value.acts_like?(:string)
 
             if value.usec > 0
-              %("#{value.to_s(:db)}.#{value.usec.to_s.remove(/0+$/)}")
+              %("#{value.to_fs(:db)}.#{value.usec.to_s.remove(/0+$/)}")
             else
-              %("#{value.to_s(:db)}")
+              %("#{value.to_fs(:db)}")
             end
           end
 
@@ -54,9 +54,9 @@ module ActiveRecord
             return %("#{value}") if value.acts_like?(:string)
 
             if value.usec > 0
-              %("#{value.to_s(:db)}.#{value.usec.to_s.remove(/0+$/)}")
+              %("#{value.to_fs(:db)}.#{value.usec.to_s.remove(/0+$/)}")
             else
-              %("#{value.to_s(:db)}")
+              %("#{value.to_fs(:db)}")
             end
           end
 
@@ -100,9 +100,9 @@ module ActiveRecord
             return %("#{value}") if value.acts_like?(:string)
 
             if value.usec > 0
-              %("#{value.to_s(:db)}.#{value.usec.to_s.remove(/0+$/)}")
+              %("#{value.to_fs(:db)}.#{value.usec.to_s.remove(/0+$/)}")
             else
-              %("#{value.to_s(:db)}")
+              %("#{value.to_fs(:db)}")
             end
           end
 

data/lib/arjdbc/mssql/types/numeric_types.rb

@@ -35,7 +35,7 @@ module ActiveRecord
         end
 
         class Money < Decimal
-          def initialize(options = {})
+          def initialize(precision: nil, limit: nil, scale: nil)
             super
             @precision = 19
             @scale = 4
@@ -46,7 +46,7 @@ module ActiveRecord
         end
 
         class SmallMoney < Decimal
-          def initialize(options = {})
+          def initialize(precision: nil, limit: nil, scale: nil)
             super
             @precision = 10
             @scale = 4

data/lib/arjdbc/mssql.rb

@@ -6,4 +6,4 @@ module ArJdbc
   MsSQL = MSSQL # compatibility with 1.2
 end
 
-ArJdbc.warn_unsupported_adapter 'mssql', [6, 1] # warns on AR >= 4.2
+ArJdbc.warn_unsupported_adapter 'mssql', [7, 0] # warns on AR >= 4.2

data/lib/arjdbc/mysql/adapter.rb

@@ -107,7 +107,8 @@ module ActiveRecord
 
       # Reloading the type map in abstract/statement_cache.rb blows up postgres
       def clear_cache!
-        reload_type_map
+        # FIXME: This seems to have disappeared in Rails 7?
+        # reload_type_map
         super
       end
 

data/lib/arjdbc/oracle/adapter.rb

@@ -40,7 +40,7 @@ module ArJdbc
       return if @@_initialized; @@_initialized = true
 
       require 'arjdbc/util/serialized_attributes'
-      Util::SerializedAttributes.setup /LOB\(|LOB$/i, 'after_save_with_oracle_lob'
+      Util::SerializedAttributes.setup %r{LOB\(|LOB$}i, 'after_save_with_oracle_lob'
 
       unless ActiveRecord::ConnectionAdapters::AbstractAdapter.
           instance_methods(false).detect { |m| m.to_s == "prefetch_primary_key?" }
@@ -285,7 +285,7 @@ module ArJdbc
           execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(index_name)} #{index_type} (#{quoted_column_names})"
         end
       end
-    end if AR42
+    end
 
     # @private
     def add_index_options(table_name, column_name, options = {})
@@ -309,7 +309,7 @@ module ArJdbc
 
       quoted_column_names = column_names.map { |e| quote_column_name_or_expression(e) }.join(", ")
       [ index_name, index_type, quoted_column_names, tablespace, index_options ]
-    end if AR42
+    end
 
     # @override
     def remove_index(table_name, options = {})
@@ -327,12 +327,7 @@ module ArJdbc
       end
       execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(index_name)}" rescue nil
       execute "DROP INDEX #{quote_column_name(index_name)}"
-    end if AR42
-
-    # @private
-    def remove_index(table_name, options = {})
-      execute "DROP INDEX #{index_name(table_name, options)}"
-    end unless AR42
+    end
 
     def change_column_default(table_name, column_name, default)
       execute "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
@@ -361,25 +356,11 @@ module ArJdbc
         "RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
     end
 
-    if ActiveRecord::VERSION::MAJOR >= 4
-
     # @override
     def remove_column(table_name, column_name, type = nil, options = {})
       do_remove_column(table_name, column_name)
     end
 
-    else
-
-    # @override
-    def remove_column(table_name, *column_names)
-      for column_name in column_names.flatten
-        do_remove_column(table_name, column_name)
-      end
-    end
-    alias remove_columns remove_column
-
-    end
-
     def do_remove_column(table_name, column_name)
       execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
     end

data/lib/arjdbc/postgresql/adapter.rb

@@ -81,7 +81,7 @@ module ArJdbc
       # If using Active Record's time zone support configure the connection to return
       # TIMESTAMP WITH ZONE types in UTC.
       # (SET TIME ZONE does not use an equals sign like other SET variables)
-      if ActiveRecord::Base.default_timezone == :utc
+      if ActiveRecord.default_timezone == :utc
         execute("SET time zone 'UTC'", 'SCHEMA')
       elsif tz = local_tz
         execute("SET time zone '#{tz}'", 'SCHEMA')
@@ -320,6 +320,38 @@ module ArJdbc
       exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
     end
 
+    # Returns a list of defined enum types, and their values.
+    def enum_types
+      query = <<~SQL
+          SELECT
+            type.typname AS name,
+            string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
+          FROM pg_enum AS enum
+          JOIN pg_type AS type
+            ON (type.oid = enum.enumtypid)
+          GROUP BY type.typname;
+      SQL
+      exec_query(query, "SCHEMA").cast_values
+    end
+
+    # Given a name and an array of values, creates an enum type.
+    def create_enum(name, values)
+      sql_values = values.map { |s| "'#{s}'" }.join(", ")
+      query = <<~SQL
+          DO $$
+          BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_type t
+                WHERE t.typname = '#{name}'
+              ) THEN
+                  CREATE TYPE \"#{name}\" AS ENUM (#{sql_values});
+              END IF;
+          END
+          $$;
+      SQL
+      exec_query(query)
+    end
+
     # Returns the configured supported identifier length supported by PostgreSQL
     def max_identifier_length
       @max_identifier_length ||= query_value("SHOW max_identifier_length", "SCHEMA").to_i
@@ -672,6 +704,37 @@ module ActiveRecord::ConnectionAdapters
   class PostgreSQLAdapter < AbstractAdapter
     class_attribute :create_unlogged_tables, default: false
 
+    ##
+    # :singleton-method:
+    # PostgreSQL allows the creation of "unlogged" tables, which do not record
+    # data in the PostgreSQL Write-Ahead Log. This can make the tables faster,
+    # but significantly increases the risk of data loss if the database
+    # crashes. As a result, this should not be used in production
+    # environments. If you would like all created tables to be unlogged in
+    # the test environment you can add the following line to your test.rb
+    # file:
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+    class_attribute :create_unlogged_tables, default: false
+
+    ##
+    # :singleton-method:
+    # PostgreSQL supports multiple types for DateTimes. By default, if you use +datetime+
+    # in migrations, Rails will translate this to a PostgreSQL "timestamp without time zone".
+    # Change this in an initializer to use another NATIVE_DATABASE_TYPES. For example, to
+    # store DateTimes as "timestamp with time zone":
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :timestamptz
+    #
+    # Or if you are adding a custom type:
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:my_custom_type] = { name: "my_custom_type_name" }
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :my_custom_type
+    #
+    # If you're using +:ruby+ as your +config.active_record.schema_format+ and you change this
+    # setting, you should immediately run <tt>bin/rails db:migrate</tt> to update the types in your schema.rb.
+    class_attribute :datetime_type, default: :timestamp
+
     # Try to use as much of the built in postgres logic as possible
     # maybe someday we can extend the actual adapter
     include ActiveRecord::ConnectionAdapters::PostgreSQL::ReferentialIntegrity

data/lib/arjdbc/postgresql/oid_types.rb

@@ -116,54 +116,57 @@ module ArJdbc
 
       private
 
-      def initialize_type_map(m = type_map)
-        register_class_with_limit m, 'int2', Type::Integer
-        register_class_with_limit m, 'int4', Type::Integer
-        register_class_with_limit m, 'int8', Type::Integer
-        m.register_type 'oid', OID::Oid.new
-        m.register_type 'float4', Type::Float.new
-        m.alias_type 'float8', 'float4'
-        m.register_type 'text', Type::Text.new
-        register_class_with_limit m, 'varchar', Type::String
-        m.alias_type 'char', 'varchar'
-        m.alias_type 'name', 'varchar'
-        m.alias_type 'bpchar', 'varchar'
-        m.register_type 'bool', Type::Boolean.new
-        register_class_with_limit m, 'bit', OID::Bit
-        register_class_with_limit m, 'varbit', OID::BitVarying
-        m.alias_type 'timestamptz', 'timestamp'
-        m.register_type 'date', OID::Date.new
-
-        m.register_type 'money', OID::Money.new
-        m.register_type 'bytea', OID::Bytea.new
-        m.register_type 'point', OID::Point.new
-        m.register_type 'hstore', OID::Hstore.new
-        m.register_type 'json', Type::Json.new
-        m.register_type 'jsonb', OID::Jsonb.new
-        m.register_type 'cidr', OID::Cidr.new
-        m.register_type 'inet', OID::Inet.new
-        m.register_type 'uuid', OID::Uuid.new
-        m.register_type 'xml', OID::Xml.new
-        m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
-        m.register_type 'macaddr', OID::Macaddr.new
-        m.register_type 'citext', OID::SpecializedString.new(:citext)
-        m.register_type 'ltree', OID::SpecializedString.new(:ltree)
-        m.register_type 'line', OID::SpecializedString.new(:line)
-        m.register_type 'lseg', OID::SpecializedString.new(:lseg)
-        m.register_type 'box', OID::SpecializedString.new(:box)
-        m.register_type 'path', OID::SpecializedString.new(:path)
-        m.register_type 'polygon', OID::SpecializedString.new(:polygon)
-        m.register_type 'circle', OID::SpecializedString.new(:circle)
-
-        m.register_type 'interval' do |*args, sql_type|
-          precision = extract_precision(sql_type)
-          OID::Interval.new(precision: precision)
-        end
+      def register_class_with_limit(...)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:register_class_with_limit, ...)
+      end
 
-        register_class_with_precision m, 'time', Type::Time
-        register_class_with_precision m, 'timestamp', OID::DateTime
+      def register_class_with_precision(...)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:register_class_with_precision, ...)
+      end
 
-        m.register_type 'numeric' do |_, fmod, sql_type|
+      def initialize_type_map(m = type_map)
+        m.register_type "int2", Type::Integer.new(limit: 2)
+        m.register_type "int4", Type::Integer.new(limit: 4)
+        m.register_type "int8", Type::Integer.new(limit: 8)
+        m.register_type "oid", OID::Oid.new
+        m.register_type "float4", Type::Float.new
+        m.alias_type "float8", "float4"
+        m.register_type "text", Type::Text.new
+        register_class_with_limit m, "varchar", Type::String
+        m.alias_type "char", "varchar"
+        m.alias_type "name", "varchar"
+        m.alias_type "bpchar", "varchar"
+        m.register_type "bool", Type::Boolean.new
+        register_class_with_limit m, "bit", OID::Bit
+        register_class_with_limit m, "varbit", OID::BitVarying
+        m.register_type "date", OID::Date.new
+
+        m.register_type "money", OID::Money.new
+        m.register_type "bytea", OID::Bytea.new
+        m.register_type "point", OID::Point.new
+        m.register_type "hstore", OID::Hstore.new
+        m.register_type "json", Type::Json.new
+        m.register_type "jsonb", OID::Jsonb.new
+        m.register_type "cidr", OID::Cidr.new
+        m.register_type "inet", OID::Inet.new
+        m.register_type "uuid", OID::Uuid.new
+        m.register_type "xml", OID::Xml.new
+        m.register_type "tsvector", OID::SpecializedString.new(:tsvector)
+        m.register_type "macaddr", OID::Macaddr.new
+        m.register_type "citext", OID::SpecializedString.new(:citext)
+        m.register_type "ltree", OID::SpecializedString.new(:ltree)
+        m.register_type "line", OID::SpecializedString.new(:line)
+        m.register_type "lseg", OID::SpecializedString.new(:lseg)
+        m.register_type "box", OID::SpecializedString.new(:box)
+        m.register_type "path", OID::SpecializedString.new(:path)
+        m.register_type "polygon", OID::SpecializedString.new(:polygon)
+        m.register_type "circle", OID::SpecializedString.new(:circle)
+
+        register_class_with_precision m, "time", Type::Time
+        register_class_with_precision m, "timestamp", OID::Timestamp
+        register_class_with_precision m, "timestamptz", OID::TimestampWithTimeZone
+
+        m.register_type "numeric" do |_, fmod, sql_type|
           precision = extract_precision(sql_type)
           scale = extract_scale(sql_type)
 
@@ -183,7 +186,10 @@ module ArJdbc
           end
         end
 
-        load_additional_types(m)
+        m.register_type "interval" do |*args, sql_type|
+          precision = extract_precision(sql_type)
+          OID::Interval.new(precision: precision)
+        end
 
         # pgjdbc returns these if the column is auto-incrmenting
         m.alias_type 'serial', 'int4'
@@ -231,6 +237,21 @@ module ArJdbc
         initializer.run(records)
       end
 
+      def extract_scale(sql_type)
+        case sql_type
+        when /\((\d+)\)/ then 0
+        when /\((\d+)(,(\d+))\)/ then $3.to_i
+        end
+      end
+
+      def extract_precision(sql_type)
+        $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+      end
+
+      def extract_limit(sql_type)
+        $1.to_i if sql_type =~ /\((.*)\)/
+      end
+
       # Support arrays/ranges for defining attributes that don't exist in the db
       ActiveRecord::Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
       ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)