sequel 3.46.0 → 3.47.0

data/lib/sequel/adapters/utils/split_alter_table.rb

@@ -27,9 +27,9 @@ module Sequel::Database::SplitAlterTable
       op_groups.last << op
     end
 
-    op_groups.each do |ops|
-      next if ops.empty?
-      alter_table_sql_list(name, ops).each{|sql| execute_ddl(sql)}
+    op_groups.each do |opgs|
+      next if opgs.empty?
+      alter_table_sql_list(name, opgs).each{|sql| execute_ddl(sql)}
       remove_cached_schema(name)
     end
   end

data/lib/sequel/connection_pool/threaded.rb

@@ -49,7 +49,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     hold do |c|
       sync do
         yield c
-        @available_connections.each{|c| yield c}
+        @available_connections.each{|conn| yield conn}
       end
     end
   end

data/lib/sequel/core.rb

@@ -369,7 +369,7 @@ module Sequel
     if rescue_rollback
       begin
         pr.call
-      rescue Sequel::Rollback => e
+      rescue Sequel::Rollback
         nil
       end
     else

data/lib/sequel/database/connecting.rb

@@ -37,7 +37,7 @@ module Sequel
         
     # Returns the scheme symbol for the Database class.
     def self.adapter_scheme
-      @scheme
+      @scheme if defined?(@scheme)
     end
     
     # Connects to a database.  See Sequel.connect.
@@ -55,7 +55,7 @@ module Sequel
           c = adapter_class(scheme)
           uri_options = c.send(:uri_to_options, uri)
           uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
-          uri_options.to_a.each{|k,v| uri_options[k] = URI.unescape(v) if v.is_a?(String)}
+          uri_options.to_a.each{|k,v| uri_options[k] = (defined?(URI::DEFAULT_PARSER) ? URI::DEFAULT_PARSER : URI).unescape(v) if v.is_a?(String)}
           opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash

data/lib/sequel/database/features.rb

@@ -53,6 +53,11 @@ module Sequel
       supports_prepared_transactions? && supports_savepoints?
     end
 
+    # Whether the database supports schema parsing via Database#schema.
+    def supports_schema_parsing?
+      respond_to?(:schema_parse_table, true)
+    end
+
     # Whether the database and adapter support transaction isolation levels, false by default.
     def supports_transaction_isolation_levels?
       false

data/lib/sequel/database/misc.rb

@@ -18,6 +18,33 @@ module Sequel
     # have specific support for the database in use.
     DEFAULT_DATABASE_ERROR_REGEXPS = {}.freeze
 
+    # Mapping of schema type symbols to class or arrays of classes for that
+    # symbol.
+    SCHEMA_TYPE_CLASSES = {:string=>String, :integer=>Integer, :date=>Date, :datetime=>[Time, DateTime].freeze,
+      :time=>Sequel::SQLTime, :boolean=>[TrueClass, FalseClass].freeze, :float=>Float, :decimal=>BigDecimal,
+      :blob=>Sequel::SQL::Blob}.freeze
+
+    # Nested hook Proc; each new hook Proc just wraps the previous one.
+    @initialize_hook = Proc.new {|db| }
+
+    # Register a hook that will be run when a new Database is instantiated. It is
+    # called with the new database handle.
+    def self.after_initialize(&block)
+      raise Error, "must provide block to after_initialize" unless block
+      Sequel.synchronize do
+        previous = @initialize_hook
+        @initialize_hook = Proc.new do |db|
+          previous.call(db)
+          block.call(db)
+        end
+      end
+    end
+
+    # Apply an extension to all Database objects created in the future.
+    def self.extension(*extensions)
+      after_initialize{|db| db.extension(*extensions)}
+    end
+
     # Register an extension callback for Database objects.  ext should be the
     # extension name symbol, and mod should either be a Module that the
     # database is extended with, or a callable object called with the database
@@ -35,6 +62,11 @@ module Sequel
       Sequel.synchronize{EXTENSIONS[ext] = block}
     end
 
+    # Run the after_initialize hook for the given +instance+.
+    def self.run_after_initialize(instance)
+      @initialize_hook.call(instance)
+    end
+
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object. 
     def self.uri_to_options(uri)
@@ -45,7 +77,7 @@ module Sequel
         :database => (m = /\/(.*)/.match(uri.path)) && (m[1]) }
     end
     private_class_method :uri_to_options
-    
+
     # The options hash for this database
     attr_reader :opts
     
@@ -93,10 +125,14 @@ module Sequel
       @dataset_class = dataset_class_default
       @cache_schema = typecast_value_boolean(@opts.fetch(:cache_schema, true))
       @dataset_modules = []
+      @schema_type_classes = SCHEMA_TYPE_CLASSES.dup
       self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
       @pool = ConnectionPool.get_pool(self, @opts)
 
-      Sequel.synchronize{::Sequel::DATABASES.push(self)}
+      unless typecast_value_boolean(@opts[:keep_reference]) == false
+        Sequel.synchronize{::Sequel::DATABASES.push(self)}
+      end
+      Sequel::Database.run_after_initialize(self)
     end
 
     # If a transaction is not currently in process, yield to the block immediately.
@@ -201,6 +237,11 @@ module Sequel
     def quote_identifier(v)
       schema_utility_dataset.quote_identifier(v)
     end
+
+    # Return ruby class or array of classes for the given type symbol.
+    def schema_type_class(type)
+      @schema_type_classes[type]
+    end
     
     # Default serial primary key options, used by the table creation
     # code.
@@ -210,6 +251,7 @@ module Sequel
 
     # Cache the prepared statement object at the given name.
     def set_prepared_statement(name, ps)
+      ps.prepared_sql
       Sequel.synchronize{prepared_statements[name] = ps}
     end
 
@@ -306,8 +348,8 @@ module Sequel
           return klass
         end
       else
-        database_error_regexps.each do |regexp, klass|
-          return klass if exception.message =~ regexp
+        database_error_regexps.each do |regexp, klss|
+          return klss if exception.message =~ regexp
         end
       end
 
@@ -349,7 +391,7 @@ module Sequel
         raise exception
       end
     end
-    
+
     # Typecast the value to an SQL::Blob
     def typecast_value_blob(value)
       value.is_a?(Sequel::SQL::Blob) ? value : Sequel::SQL::Blob.new(value)

data/lib/sequel/database/query.rb

@@ -154,7 +154,7 @@ module Sequel
     #   #    :db_type=>"text",
     #   #    :allow_null=>false}]]
     def schema(table, opts={})
-      raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)
+      raise(Error, 'schema parsing is not implemented on this database') unless supports_schema_parsing?
 
       opts = opts.dup
       tab = if table.is_a?(Dataset)
@@ -312,7 +312,7 @@ module Sequel
     # for this database.  Used when parsing metadata so that column symbols are
     # returned as expected.
     def metadata_dataset
-      return @metadata_dataset if @metadata_dataset
+      return @metadata_dataset if defined?(@metadata_dataset) && @metadata_dataset
       ds = dataset
       ds.identifier_input_method = identifier_input_method_default
       ds.identifier_output_method = identifier_output_method_default

data/lib/sequel/dataset/actions.rb

@@ -148,7 +148,7 @@ module Sequel
     def each
       if @opts[:graph]
         graph_each{|r| yield r}
-      elsif row_proc = @row_proc
+      elsif defined?(@row_proc) && (row_proc = @row_proc)
         fetch_rows(select_sql){|r| yield row_proc.call(r)}
       else
         fetch_rows(select_sql){|r| yield r}
@@ -262,7 +262,9 @@ module Sequel
       end
 
       if column.is_a?(Array)
-        ds.single_record.values_at(*column.map{|c| hash_key_symbol(c)})
+       if r = ds.single_record
+         r.values_at(*column.map{|c| hash_key_symbol(c)})
+       end
       else
         ds.single_value
       end

data/lib/sequel/dataset/misc.rb

@@ -81,7 +81,7 @@ module Sequel
       when SQL::AliasedExpression
         s.aliaz
       when Symbol
-        sch, table, aliaz = split_symbol(s)
+        _, _, aliaz = split_symbol(s)
         aliaz ? aliaz.to_sym : s
       else
         s

data/lib/sequel/dataset/prepared_statements.rb

@@ -29,7 +29,7 @@ module Sequel
       # Override the given *_sql method based on the type, and
       # cache the result of the sql.
       def prepared_sql
-        return @prepared_sql if @prepared_sql
+        return @prepared_sql if defined?(@prepared_sql) && @prepared_sql
         @prepared_args ||= []
         @prepared_sql = super
         @opts[:sql] = @prepared_sql

data/lib/sequel/dataset/query.rb

@@ -495,7 +495,7 @@ module Sequel
       using_join = expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)}
       if using_join && !supports_join_using?
         h = {}
-        expr.each{|s| h[s] = s}
+        expr.each{|e| h[e] = e}
         return join_table(type, table, h, options)
       end
 
@@ -600,11 +600,14 @@ module Sequel
     end
     
     # Returns a cloned dataset with the given lock style.  If style is a
-    # string, it will be used directly.  Otherwise, a symbol may be used
-    # for database independent locking.  Currently :update is respected
-    # by most databases, and :share is supported by some.
+    # string, it will be used directly. You should never pass a string
+    # to this method that is derived from user input, as that can lead to
+    # SQL injection.
     #
-    #   DB[:items].lock_style('FOR SHARE') # SELECT * FROM items FOR SHARE
+    # A symbol may be used for database independent locking behavior, but
+    # all supported symbols have separate methods (e.g. for_update).
+    #
+    #   DB[:items].lock_style('FOR SHARE NOWAIT') # SELECT * FROM items FOR SHARE NOWAIT
     def lock_style(style)
       clone(:lock => style)
     end
@@ -1107,7 +1110,6 @@ module Sequel
     #   DB[:items].invert_order([:category, Sequel.desc(:price)]) #=> [Sequel.desc(:category), Sequel.asc(:price)]
     def invert_order(order)
       return nil unless order
-      new_order = []
       order.map do |f|
         case f
         when SQL::OrderedExpression

data/lib/sequel/dataset/sql.rb

@@ -150,7 +150,9 @@ module Sequel
       else
         check_truncation_allowed!
         raise(InvalidOperation, "Can't truncate filtered datasets") if opts[:where] || opts[:having]
-        _truncate_sql(source_list(opts[:from]))
+        t = ''
+        source_list_append(t, opts[:from])
+        _truncate_sql(t)
       end
     end
 
@@ -345,7 +347,7 @@ module Sequel
       end
     end
     def_append_methods(PUBLIC_APPEND_METHODS + PRIVATE_APPEND_METHODS)
-    private *PRIVATE_APPEND_METHODS
+    private(*PRIVATE_APPEND_METHODS)
 
     # SQL fragment for AliasedExpression
     def aliased_expression_sql_append(sql, ae)
@@ -412,11 +414,11 @@ module Sequel
       when *IS_OPERATORS
         r = args.at(1)
         if r.nil? || supports_is_true?
-          raise(InvalidOperation, 'Invalid argument used for IS operator') unless v = IS_LITERALS[r]
+          raise(InvalidOperation, 'Invalid argument used for IS operator') unless val = IS_LITERALS[r]
           sql << PAREN_OPEN
           literal_append(sql, args.at(0))
           sql << SPACE << op.to_s << SPACE
-          sql << v << PAREN_CLOSE
+          sql << val << PAREN_CLOSE
         elsif op == :IS
           complex_expression_sql_append(sql, :"=", args)
         else
@@ -667,7 +669,7 @@ module Sequel
       sch = sch.to_s if sch
       case table_name
       when Symbol
-        s, t, a = split_symbol(table_name)
+        s, t, _ = split_symbol(table_name)
         [s||sch, t]
       when SQL::QualifiedIdentifier
         [table_name.table.to_s, table_name.column.to_s]
@@ -1195,7 +1197,7 @@ module Sequel
     # name isn't already qualified.
     def qualified_column_name(column, table)
       if Symbol === column 
-        c_table, column, c_alias = split_symbol(column)
+        c_table, column, _ = split_symbol(column)
         unless c_table
           case table
           when Symbol

data/lib/sequel/extensions/constraint_validations.rb

@@ -357,7 +357,7 @@ module Sequel
         when :includes
           generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
           if arg.is_a?(Range)
-            if (b = arg.begin).is_a?(Integer) && (e = arg.end).is_a?(Integer)
+            if arg.begin.is_a?(Integer) && arg.end.is_a?(Integer)
               validation_type = :includes_int_range
               arg = "#{arg.begin}..#{'.' if arg.exclude_end?}#{arg.end}"
             else
@@ -410,7 +410,10 @@ module Sequel
     # Add the constraint to the generator, including a NOT NULL constraint
     # for all columns unless the :allow_nil option is given.
     def generator_add_constraint_from_validation(generator, val, cons)
-      unless val[:allow_nil]
+      if val[:allow_nil]
+        nil_cons = Sequel.expr(val[:columns].map{|c| [c, nil]})
+        cons = Sequel.|(nil_cons, cons) if cons
+      else
         nil_cons = Sequel.negate(val[:columns].map{|c| [c, nil]})
         cons = cons ? Sequel.&(nil_cons, cons) : nil_cons
       end

data/lib/sequel/extensions/migration.rb

@@ -85,7 +85,7 @@ module Sequel
     # Whether to use transactions for this migration, default depends on the
     # database.
     attr_accessor :use_transactions
-
+    
     # Don't set transaction use by default.
     def initialize
       @use_transactions = nil
@@ -374,11 +374,12 @@ module Sequel
     end
 
     # Migrates the supplied database using the migration files in the the specified directory. Options:
-    # * :column :: The column in the :table argument storing the migration version (default: :version).
-    # * :current :: The current version of the database.  If not given, it is retrieved from the database
-    #               using the :table and :column options.
-    # * :table :: The table containing the schema version (default: :schema_info).
-    # * :target :: The target version to which to migrate.  If not given, migrates to the maximum version.
+    # :allow_missing_migration_files :: Don't raise an error if there are missing migration files.
+    # :column :: The column in the :table argument storing the migration version (default: :version).
+    # :current :: The current version of the database.  If not given, it is retrieved from the database
+    #             using the :table and :column options.
+    # :table :: The table containing the schema version (default: :schema_info).
+    # :target :: The target version to which to migrate.  If not given, migrates to the maximum version.
     #
     # Examples: 
     #   Sequel::Migrator.run(DB, "migrations")
@@ -435,6 +436,7 @@ module Sequel
       raise(Error, "Must supply a valid migration path") unless File.directory?(directory)
       @db = db
       @directory = directory
+      @allow_missing_migration_files = opts[:allow_missing_migration_files]
       @files = get_migration_files
       schema, table = @db.send(:schema_and_table, opts[:table]  || self.class.const_get(:DEFAULT_SCHEMA_TABLE))
       @table = schema ? Sequel::SQL::QualifiedIdentifier.new(schema, table) : table
@@ -553,7 +555,7 @@ module Sequel
         raise(Error, "Duplicate migration version: #{version}") if files[version]
         files[version] = File.join(directory, file)
       end
-      1.upto(files.length - 1){|i| raise(Error, "Missing migration version: #{i}") unless files[i]}
+      1.upto(files.length - 1){|i| raise(Error, "Missing migration version: #{i}") unless files[i]} unless @allow_missing_migration_files
       files
     end
     
@@ -674,7 +676,7 @@ module Sequel
     def get_applied_migrations
       am = ds.select_order_map(column)
       missing_migration_files = am - files.map{|f| File.basename(f).downcase}
-      raise(Error, "Applied migration files not in file system: #{missing_migration_files.join(', ')}") if missing_migration_files.length > 0
+      raise(Error, "Applied migration files not in file system: #{missing_migration_files.join(', ')}") if missing_migration_files.length > 0 && !@allow_missing_migration_files
       am
     end
     

data/lib/sequel/extensions/pagination.rb

@@ -103,4 +103,7 @@ module Sequel
       end
     end
   end
+
+  Database.register_extension(:pagination){}
+  Dataset.register_extension(:pagination){}
 end

data/lib/sequel/extensions/pg_array.rb

@@ -17,8 +17,8 @@
 #
 #   Sequel.pg_array(array)
 #
-# If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html],
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html]
 # and have activated refinements for the file, you can also use Array#pg_array:
 #
 #   array.pg_array
@@ -32,15 +32,14 @@
 #
 #   DB[:table].insert(:column=>Sequel.pg_array([1, 2, 3]))
 #
-# If you would like to use PostgreSQL arrays in your model objects, you
-# probably want to modify the schema parsing/typecasting so that it
-# recognizes and correctly handles the arrays, which you can do by:
+# To use this extension, first load it into your Sequel::Database instance:
 #
 #   DB.extension :pg_array
 #
-# If you are not using the native postgres adapter, you probably
-# also want to use the typecast_on_load plugin in the model, and
-# set it to typecast the array column(s) on load.
+# If you are not using the native postgres adapter and are using array
+# types as model column values you probably should use the
+# pg_typecast_on_load plugin in the model, and set it to typecast the
+# array column(s) on load.
 #
 # This extension by default includes handlers for array types for
 # all scalar types that the native postgres adapter handles. It
@@ -48,18 +47,24 @@
 # general, you just need to make sure that the scalar type is
 # handled and has the appropriate converter installed in
 # Sequel::Postgres::PG_TYPES under the appropriate type OID.
-# Then you can call Sequel::Postgres::PGArray.register with
-# the appropriate arguments to automatically set up a handler
-# for the array type.
+# Then you can call
+# Sequel::Postgres::PGArray::DatabaseMethods#register_array_type
+# to automatically set up a handler for the array type.  So if you
+# want to support the foo[] type (assuming the foo type is already
+# supported):
 #
-# For example, if you add support for a scalar custom type named
-# foo which uses OID 1234, and you want to add support for the
-# foo[] type, which uses type OID 4321, you need to do:
+#   DB.register_array_type('foo')
+#
+# You can also register array types on a global basis using
+# Sequel::Postgres::PGArray.register.  In this case, you'll have
+# to specify the type oids:
 #
 #   Sequel::Postgres::PGArray.register('foo', :oid=>4321, :scalar_oid=>1234)
 #
-# Sequel::Postgres::PGArray.register has many additional options
-# and should be able to handle most PostgreSQL array types.
+# Both Sequel::Postgres::PGArray::DatabaseMethods#register_array_type
+# and Sequel::Postgres::PGArray.register support many options to
+# customize the array type handling.  See the Sequel::Postgres::PGArray.register
+# method documentation.
 #
 # If you want an easy way to call PostgreSQL array functions and
 # operators, look into the pg_array_ops extension.
@@ -115,8 +120,8 @@ module Sequel
       NULL = 'NULL'.freeze
       QUOTE = '"'.freeze
 
-      # Hash of database array type name strings to symbols (e.g. 'double precision' => :float),
-      # used by the schema parsing.
+      # Global hash of database array type name strings to symbols (e.g. 'double precision' => :float),
+      # used by the schema parsing for array types registered globally.
       ARRAY_TYPES = {}
 
       # Registers an array type that the extension should handle.  Makes a Database instance that
@@ -153,6 +158,8 @@ module Sequel
       #                     typecasting method to be created in the database.  This should only be used
       #                     to alias existing array types.  For example, if there is an array type that can be
       #                     treated just like an integer array, you can do :typecast_method=>:integer.
+      # :typecast_method_map :: The map in which to place the database type string to type symbol mapping.
+      #                         Defaults to ARRAY_TYPES.
       # :typecast_methods_module :: If given, a module object to add the typecasting method to.  Defaults
       #                             to DatabaseMethods.
       #
@@ -163,6 +170,7 @@ module Sequel
         type = (typecast_method || opts[:type_symbol] || db_type).to_sym
         type_procs = opts[:type_procs] || PG_TYPES
         mod = opts[:typecast_methods_module] || DatabaseMethods
+        typecast_method_map = opts[:typecast_method_map] || ARRAY_TYPES
 
         if converter = opts[:converter]
           raise Error, "can't provide both a block and :converter option to register" if block
@@ -178,7 +186,7 @@ module Sequel
         array_type = (opts[:array_type] || db_type).to_s.dup.freeze
         creator = (opts[:parser] == :json ? JSONCreator : Creator).new(array_type, converter)
 
-        ARRAY_TYPES[db_type] = :"#{type}_array"
+        typecast_method_map[db_type] = :"#{type}_array"
 
         define_array_typecast_method(mod, type, creator, opts.fetch(:scalar_typecast, type)) unless typecast_method
 
@@ -208,6 +216,22 @@ module Sequel
         ESCAPE_REPLACEMENT = '\\\\\1'.freeze
         BLOB_RANGE = 1...-1
 
+        # Create the local hash of database type strings to schema type symbols,
+        # used for array types local to this database.
+        def self.extended(db)
+          db.instance_eval do
+            @pg_array_schema_types ||= {}
+            copy_conversion_procs([1009, 1007, 1016, 1231, 1022, 1000, 1001, 1182, 1183, 1270, 1005, 1028, 1021, 1014, 1015])
+            [:string_array, :integer_array, :decimal_array, :float_array, :boolean_array, :blob_array, :date_array, :time_array, :datetime_array].each do |v|
+              @schema_type_classes[v] = PGArray
+            end
+          end
+
+          procs = db.conversion_procs
+          procs[1115] = Creator.new("timestamp without time zone", procs[1114])
+          procs[1185] = Creator.new("timestamp with time zone", procs[1184])
+        end
+
         # Handle arrays in bound variables
         def bound_variable_arg(arg, conn)
           case arg
@@ -220,13 +244,24 @@ module Sequel
           end
         end
 
-        # Make the column type detection handle registered array types.
-        def schema_column_type(db_type)
-          if (db_type =~ /\A([^(]+)(?:\([^(]+\))?\[\]\z/io) && (type = ARRAY_TYPES[$1])
-            type
-          else
-            super
+        # Register a database specific array type.  This can be used to support
+        # different array types per Database.  Use of this method does not
+        # affect global state, unlike PGArray.register.  See PGArray.register for
+        # possible options.
+        def register_array_type(db_type, opts={}, &block)
+          opts = {:type_procs=>conversion_procs, :typecast_method_map=>@pg_array_schema_types, :typecast_methods_module=>(class << self; self; end)}.merge(opts)
+          unless (opts.has_key?(:scalar_oid) || block) && opts.has_key?(:oid)
+            array_oid, scalar_oid = from(:pg_type).where(:typname=>db_type.to_s).get([:typarray, :oid])
+            opts[:scalar_oid] = scalar_oid unless opts.has_key?(:scalar_oid) || block
+            opts[:oid] = array_oid unless opts.has_key?(:oid)
           end
+          PGArray.register(db_type, opts, &block)
+          @schema_type_classes[:"#{opts[:typecast_method] || opts[:type_symbol] || db_type}_array"] = PGArray
+        end
+
+        # Return PGArray if this type matches any supported array type.
+        def schema_type_class(type)
+          super || (ARRAY_TYPES.each_value{|v| return PGArray if type == v}; nil)
         end
 
         private
@@ -247,6 +282,15 @@ module Sequel
           end
         end
 
+        # Automatically handle array types for the given named types. 
+        def convert_named_procs_to_procs(named_procs)
+          h = super
+          from(:pg_type).where(:oid=>h.keys).select_map([:typname, :oid, :typarray]).each do |name, scalar_oid, array_oid|
+            register_array_type(name, :type_procs=>h, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
+          end
+          h
+        end
+
         # Manually override the typecasting for timestamp array types so that
         # they use the database's timezone instead of the global Sequel
         # timezone.
@@ -259,6 +303,22 @@ module Sequel
           procs
         end
 
+        # Look into both the current database's array schema types and the global
+        # array schema types to get the type symbol for the given database type
+        # string.
+        def pg_array_schema_type(type)
+          @pg_array_schema_types[type] || ARRAY_TYPES[type]
+        end
+
+        # Make the column type detection handle registered array types.
+        def schema_column_type(db_type)
+          if (db_type =~ /\A([^(]+)(?:\([^(]+\))?\[\]\z/io) && (type = pg_array_schema_type($1))
+            type
+          else
+            super
+          end
+        end
+
         # Given a value to typecast and the type of PGArray subclass:
         # * If given a PGArray with a matching array_type, use it directly.
         # * If given a PGArray with a different array_type, return a PGArray