sequel 4.36.0 → 5.61.0

data/lib/sequel/database/misc.rb

@@ -26,16 +26,8 @@ module Sequel
       :time=>Sequel::SQLTime, :boolean=>[TrueClass, FalseClass].freeze, :float=>Float, :decimal=>BigDecimal,
       :blob=>Sequel::SQL::Blob}.freeze
 
-    # Module to be included in shared adapters so that when the DatabaseMethods are
-    # included in the database, the identifier mangling defaults are reset correctly.
-    module ResetIdentifierMangling
-      def extended(obj)
-        obj.send(:reset_identifier_mangling)
-      end
-    end
-
     # Nested hook Proc; each new hook Proc just wraps the previous one.
-    @initialize_hook = Proc.new {|db| }
+    @initialize_hook = proc{|db| }
 
     # Register a hook that will be run when a new Database is instantiated. It is
     # called with the new database handle.
@@ -43,7 +35,7 @@ module Sequel
       raise Error, "must provide block to after_initialize" unless block
       Sequel.synchronize do
         previous = @initialize_hook
-        @initialize_hook = Proc.new do |db|
+        @initialize_hook = proc do |db|
           previous.call(db)
           block.call(db)
         end
@@ -84,7 +76,7 @@ module Sequel
         :user => uri.user,
         :password => uri.password,
         :port => uri.port,
-        :host => RUBY_VERSION < '1.9.3' ? uri.host : uri.hostname,
+        :host => uri.hostname,
         :database => (m = /\/(.*)/.match(uri.path)) && (m[1])
       }
     end
@@ -99,23 +91,44 @@ module Sequel
     # The specific default size of string columns for this Sequel::Database, usually 255 by default.
     attr_accessor :default_string_column_size
 
+    # Whether to check the bytesize of strings before typecasting (to avoid typecasting strings that
+    # would be too long for the given type), true by default. Strings that are too long will raise
+    # a typecasting error.
+    attr_accessor :check_string_typecast_bytesize
+
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
     # Accepts the following options:
+    # :before_preconnect :: Callable that runs after extensions from :preconnect_extensions are loaded,
+    #                       but before any connections are created.
+    # :cache_schema :: Whether schema should be cached for this Database instance
+    # :check_string_typecast_bytesize :: Whether to check the bytesize of strings before typecasting.
     # :default_string_column_size :: The default size of string columns, 255 by default.
-    # :identifier_input_method :: A string method symbol to call on identifiers going into the database.
-    # :identifier_output_method :: A string method symbol to call on identifiers coming from the database.
+    # :extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
+    #                or string with extensions separated by columns.  These extensions are loaded after
+    #                connections are made by the :preconnect option.
+    # :keep_reference :: Whether to keep a reference to this instance in Sequel::DATABASES, true by default.
     # :logger :: A specific logger to use.
     # :loggers :: An array of loggers to use.
-    # :name :: A name to use for the Database object.
-    # :preconnect :: Whether to automatically connect to the maximum number of servers.
+    # :log_connection_info :: Whether connection information should be logged when logging queries.
+    # :log_warn_duration :: The number of elapsed seconds after which queries should be logged at warn level.
+    # :name :: A name to use for the Database object, displayed in PoolTimeout.
+    # :preconnect :: Automatically create the maximum number of connections, so that they don't
+    #                need to be created as needed.  This is useful when connecting takes a long time
+    #                and you want to avoid possible latency during runtime.
+    #                Set to :concurrently to create the connections in separate threads. Otherwise
+    #                they'll be created sequentially.
+    # :preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
+    #                           connections are made by the :preconnect option.
     # :quote_identifiers :: Whether to quote identifiers.
-    # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol .
+    # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol.
     # :single_threaded :: Whether to use a single-threaded connection pool.
     # :sql_log_level :: Method to use to log SQL to a logger, :info by default.
     #
-    # All options given are also passed to the connection pool.
+    # All options given are also passed to the connection pool.  Additional options respected by
+    # the connection pool are :after_connect, :connect_sqls, :max_connections, :pool_timeout,
+    # :servers, and :servers_hash.  See the connection pool documentation for details.
     def initialize(opts = OPTS)
       @opts ||= opts
       @opts = connection_pool_default_options.merge(@opts)
@@ -123,22 +136,21 @@ module Sequel
       @opts[:servers] = {} if @opts[:servers].is_a?(String)
       @sharded = !!@opts[:servers]
       @opts[:adapter_class] = self.class
-      @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Database.single_threaded))
+      @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Sequel.single_threaded))
       @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
+      @check_string_typecast_bytesize = typecast_value_boolean(@opts.fetch(:check_string_typecast_bytesize, true))
 
       @schemas = {}
       @prepared_statements = {}
       @transactions = {}
       @symbol_literal_cache = {}
 
-      @identifier_input_method = nil
-      @identifier_output_method = nil
-      @quote_identifiers = nil
       @timezone = nil
 
       @dataset_class = dataset_class_default
       @cache_schema = typecast_value_boolean(@opts.fetch(:cache_schema, true))
       @dataset_modules = []
+      @loaded_extensions = []
       @schema_type_classes = SCHEMA_TYPE_CLASSES.dup
 
       self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
@@ -147,55 +159,60 @@ module Sequel
 
       @pool = ConnectionPool.get_pool(self, @opts)
 
-      reset_identifier_mangling
+      reset_default_dataset
       adapter_initialize
 
-      unless typecast_value_boolean(@opts[:keep_reference]) == false
-        Sequel.synchronize{::Sequel::DATABASES.push(self)}
-      end
-      Sequel::Database.run_after_initialize(self)
-      if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
-        concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
-        @pool.send(:preconnect, concurrent)
-      end
-    end
+      keep_reference = typecast_value_boolean(@opts[:keep_reference]) != false
+      begin
+        Sequel.synchronize{::Sequel::DATABASES.push(self)} if keep_reference
+        Sequel::Database.run_after_initialize(self)
 
-    # If a transaction is not currently in process, yield to the block immediately.
-    # Otherwise, add the block to the list of blocks to call after the currently
-    # in progress transaction commits (and only if it commits).
-    # Options:
-    # :server :: The server/shard to use.
-    def after_commit(opts=OPTS, &block)
-      raise Error, "must provide block to after_commit" unless block
-      synchronize(opts[:server]) do |conn|
-        if h = _trans(conn)
-          raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
-          add_transaction_hook(conn, :after_commit, block)
-        else
-          yield
+        initialize_load_extensions(:preconnect_extensions)
+
+        if before_preconnect = @opts[:before_preconnect]
+          before_preconnect.call(self)
         end
-      end
-    end
-    
-    # If a transaction is not currently in progress, ignore the block.
-    # Otherwise, add the block to the list of the blocks to call after the currently
-    # in progress transaction rolls back (and only if it rolls back).
-    # Options:
-    # :server :: The server/shard to use.
-    def after_rollback(opts=OPTS, &block)
-      raise Error, "must provide block to after_rollback" unless block
-      synchronize(opts[:server]) do |conn|
-        if h = _trans(conn)
-          raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
-          add_transaction_hook(conn, :after_rollback, block)
+
+        if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
+          concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
+          @pool.send(:preconnect, concurrent)
         end
+
+        initialize_load_extensions(:extensions)
+        test_connection if typecast_value_boolean(@opts.fetch(:test, true)) && respond_to?(:connect, true)
+      rescue
+        Sequel.synchronize{::Sequel::DATABASES.delete(self)} if keep_reference
+        raise
       end
     end
-    
+
+    # Freeze internal data structures for the Database instance.
+    def freeze
+      valid_connection_sql
+      metadata_dataset
+      @opts.freeze
+      @loggers.freeze
+      @pool.freeze
+      @dataset_class.freeze
+      @dataset_modules.freeze
+      @schema_type_classes.freeze
+      @loaded_extensions.freeze
+      metadata_dataset
+      super
+    end
+
+    # Disallow dup/clone for Database instances
+    undef_method :dup, :clone, :initialize_copy
+    # :nocov:
+    if RUBY_VERSION >= '1.9.3'
+    # :nocov:
+      undef_method :initialize_clone, :initialize_dup
+    end
+
     # Cast the given type to a literal type
     #
     #   DB.cast_type_literal(Float) # double precision
-    #   DB.cast_type_literal(:foo) # foo
+    #   DB.cast_type_literal(:foo)  # foo
     def cast_type_literal(type)
       type_literal(:type=>type)
     end
@@ -209,7 +226,9 @@ module Sequel
       Sequel.extension(*exts)
       exts.each do |ext|
         if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          pr.call(self)
+          if Sequel.synchronize{@loaded_extensions.include?(ext) ? false : (@loaded_extensions << ext)}
+            pr.call(self)
+          end
         else
           raise(Error, "Extension #{ext} does not have specific support handling individual databases (try: Sequel.extension #{ext.inspect})")
         end
@@ -224,13 +243,6 @@ module Sequel
       Sequel.convert_output_timestamp(v, timezone)
     end
 
-    # Return true if already in a transaction given the options,
-    # false otherwise.  Respects the :server option for selecting
-    # a shard.
-    def in_transaction?(opts=OPTS)
-      synchronize(opts[:server]){|conn| !!_trans(conn)}
-    end
-
     # Returns a string representation of the database object including the
     # class name and connection URI and options used when connecting (if any).
     def inspect
@@ -244,8 +256,8 @@ module Sequel
 
     # Proxy the literal call to the dataset.
     #
-    #   DB.literal(1) # 1
-    #   DB.literal(:a) # a
+    #   DB.literal(1)   # 1
+    #   DB.literal(:a)  # a
     #   DB.literal('a') # 'a'
     def literal(v)
       schema_utility_dataset.literal(v)
@@ -279,20 +291,18 @@ module Sequel
       @schema_type_classes[type]
     end
     
-    # Default serial primary key options, used by the table creation
-    # code.
+    # Default serial primary key options, used by the table creation code.
     def serial_primary_key_options
       {:primary_key => true, :type => Integer, :auto_increment => true}
     end
 
     # 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
 
     # Whether this database instance uses multiple servers, either for sharding
-    # or for master/slave.
+    # or for primary/replica configurations.
     def sharded?
       @sharded
     end
@@ -318,6 +328,7 @@ module Sequel
       return nil if value.nil?
       meth = "typecast_value_#{column_type}"
       begin
+        # Allow calling private methods as per-type typecasting methods are private
         respond_to?(meth, true) ? send(meth, value) : value
       rescue ArgumentError, TypeError => e
         raise Sequel.convert_exception_class(e, InvalidValue)
@@ -341,13 +352,6 @@ module Sequel
     def adapter_initialize
     end
 
-    # Set the given callable as a hook to be called. Type should be either
-    # :after_commit or :after_rollback.
-    def add_transaction_hook(conn, type, block)
-      hooks = _trans(conn)[type] ||= []
-      hooks << block
-    end
-
     # Returns true when the object is considered blank.
     # The only objects that are blank are nil, false,
     # strings with all whitespace, and ones that respond
@@ -366,11 +370,6 @@ module Sequel
       end
     end
 
-    # Which transaction errors to translate, blank by default.
-    def database_error_classes
-      []
-    end
-
     # An enumerable yielding pairs of regexps and exception classes, used
     # to match against underlying driver exception messages in
     # order to raise a more specific Sequel::DatabaseError subclass.
@@ -384,8 +383,7 @@ module Sequel
       database_specific_error_class(exception, opts) || DatabaseError
     end
     
-    # Return the SQLState for the given exception, if one can be
-    # determined
+    # Return the SQLState for the given exception, if one can be determined
     def database_exception_sqlstate(exception, opts)
       nil
     end
@@ -435,8 +433,24 @@ module Sequel
       opts[:disconnect]
     end
     
+    # Load extensions during initialization from the given key in opts.
+    def initialize_load_extensions(key)
+      case exts = @opts[key]
+      when String
+        extension(*exts.split(',').map(&:to_sym))
+      when Array
+        extension(*exts)
+      when Symbol
+        extension(exts)
+      when nil
+        # nothing
+      else
+        raise Error, "unsupported Database #{key.inspect} option: #{@opts[key].inspect}"
+      end
+    end
+
     # Convert the given exception to an appropriate Sequel::DatabaseError
-    # subclass, keeping message and traceback.
+    # subclass, keeping message and backtrace.
     def raise_error(exception, opts=OPTS)
       if !opts[:classes] || Array(opts[:classes]).any?{|c| exception.is_a?(c)}
         raise Sequel.convert_exception_class(exception, database_error_class(exception, opts))
@@ -445,6 +459,34 @@ module Sequel
       end
     end
 
+    # Swallow database errors, unless they are connect/disconnect errors.
+    def swallow_database_error
+      yield
+    rescue Sequel::DatabaseDisconnectError, DatabaseConnectionError
+      # Always raise disconnect errors
+      raise
+    rescue Sequel::DatabaseError
+      # Don't raise other database errors.
+      nil
+    # else
+    #   Don't rescue other exceptions, they will be raised normally.
+    end
+
+    # Check the bytesize of a string before conversion. There is no point
+    # trying to typecast strings that would be way too long.
+    def typecast_check_string_length(string, max_size)
+      if @check_string_typecast_bytesize && string.bytesize > max_size
+        raise InvalidValue, "string too long to typecast (bytesize: #{string.bytesize}, max: #{max_size})"
+      end
+      string
+    end
+
+    # Check the bytesize of the string value, if value is a string.
+    def typecast_check_length(value, max_size)
+      typecast_check_string_length(value, max_size) if String === value
+      value
+    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)
@@ -468,9 +510,9 @@ module Sequel
       when Date
         value
       when String
-        Sequel.string_to_date(value)
+        Sequel.string_to_date(typecast_check_string_length(value, 100))
       when Hash
-        Date.new(*[:year, :month, :day].map{|x| (value[x] || value[x.to_s]).to_i})
+        Date.new(*[:year, :month, :day].map{|x| typecast_check_length(value[x] || value[x.to_s], 100).to_i})
       else
         raise InvalidValue, "invalid value for Date: #{value.inspect}"
       end
@@ -478,18 +520,26 @@ module Sequel
 
     # Typecast the value to a DateTime or Time depending on Sequel.datetime_class
     def typecast_value_datetime(value)
-      Sequel.typecast_to_application_timestamp(value)
-    end
-
-    # Typecast the value to a BigDecimal
-    def typecast_value_decimal(value)
       case value
-      when BigDecimal
-        value
-      when Numeric
-        BigDecimal.new(value.to_s)
       when String
-        d = BigDecimal.new(value)
+        Sequel.typecast_to_application_timestamp(typecast_check_string_length(value, 100))
+      when Hash
+        [:year, :month, :day, :hour, :minute, :second, :nanos, :offset].each do |x|
+          typecast_check_length(value[x] || value[x.to_s], 100)
+        end
+        Sequel.typecast_to_application_timestamp(value)
+      else
+        Sequel.typecast_to_application_timestamp(value)
+      end
+    end
+    
+    if RUBY_VERSION >= '2.4'
+      # Typecast a string to a BigDecimal
+      alias _typecast_value_string_to_decimal BigDecimal
+    else
+      # :nocov:
+      def _typecast_value_string_to_decimal(value)
+        d = BigDecimal(value)
         if d.zero?
           # BigDecimal parsing is loose by default, returning a 0 value for
           # invalid input.  If a zero value is received, use Float to check
@@ -501,6 +551,19 @@ module Sequel
           end
         end
         d
+      end
+      # :nocov:
+    end
+
+    # Typecast the value to a BigDecimal
+    def typecast_value_decimal(value)
+      case value
+      when BigDecimal
+        value
+      when Numeric
+        BigDecimal(value.to_s)
+      when String
+        _typecast_value_string_to_decimal(typecast_check_string_length(value, 1000))
       else
         raise InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
       end
@@ -508,26 +571,22 @@ module Sequel
 
     # Typecast the value to a Float
     def typecast_value_float(value)
-      Float(value)
+      Float(typecast_check_length(value, 1000))
     end
 
-    # Used for checking/removing leading zeroes from strings so they don't get
-    # interpreted as octal.
-    LEADING_ZERO_RE = /\A0+(\d)/.freeze
-    if RUBY_VERSION >= '1.9'
-      # Typecast the value to an Integer
-      def typecast_value_integer(value)
-        (value.is_a?(String) && value =~ LEADING_ZERO_RE) ? Integer(value, 10) : Integer(value)
-      end
-    else
-    # :nocov:
-      # Replacement string when replacing leading zeroes.
-      LEADING_ZERO_REP = "\\1".freeze 
-      # Typecast the value to an Integer
-      def typecast_value_integer(value)
-        Integer(value.is_a?(String) ? value.sub(LEADING_ZERO_RE, LEADING_ZERO_REP) : value)
+    # Typecast the value to an Integer
+    def typecast_value_integer(value)
+      case value
+      when String
+        typecast_check_string_length(value, 100)
+        if value =~ /\A-?0+(\d)/
+          Integer(value, 10)
+        else
+          Integer(value)
+        end
+      else
+        Integer(value)
       end
-    # :nocov:
     end
 
     # Typecast the value to a String
@@ -547,13 +606,12 @@ module Sequel
         if value.is_a?(SQLTime)
           value
         else
-          # specifically check for nsec == 0 value to work around JRuby 1.6 ruby 1.9 mode bug
-          SQLTime.create(value.hour, value.min, value.sec, (value.respond_to?(:nsec) && value.nsec != 0) ? value.nsec/1000.0 : value.usec)
+          SQLTime.create(value.hour, value.min, value.sec, value.nsec/1000.0)
         end
       when String
-        Sequel.string_to_time(value)
+        Sequel.string_to_time(typecast_check_string_length(value, 100))
       when Hash
-        SQLTime.create(*[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
+        SQLTime.create(*[:hour, :minute, :second].map{|x| typecast_check_length(value[x] || value[x.to_s], 100).to_i})
       else
         raise Sequel::InvalidValue, "invalid value for Time: #{value.inspect}"
       end

data/lib/sequel/database/query.rb

@@ -7,10 +7,8 @@ module Sequel
     # This methods generally execute SQL code on the database server.
     # ---------------------
 
-    STRING_DEFAULT_RE = /\A'(.*)'\z/
-    CURRENT_TIMESTAMP_RE = /now|today|CURRENT|getdate|\ADate\(\)\z/io
-    COLUMN_SCHEMA_DATETIME_TYPES = [:date, :datetime]
-    COLUMN_SCHEMA_STRING_TYPES = [:string, :blob, :date, :datetime, :time, :enum, :set, :interval]
+    COLUMN_SCHEMA_DATETIME_TYPES = [:date, :datetime].freeze
+    COLUMN_SCHEMA_STRING_TYPES = [:string, :blob, :date, :datetime, :time, :enum, :set, :interval].freeze
 
     # The prepared statement object hash for this database, keyed by name symbol
     attr_reader :prepared_statements
@@ -32,9 +30,9 @@ module Sequel
     # Call the prepared statement with the given name with the given hash
     # of arguments.
     #
-    #   DB[:items].filter(:id=>1).prepare(:first, :sa)
+    #   DB[:items].where(id: 1).prepare(:first, :sa)
     #   DB.call(:sa) # SELECT * FROM items WHERE id = 1
-    def call(ps_name, hash={}, &block)
+    def call(ps_name, hash=OPTS, &block)
       prepared_statement(ps_name).call(hash, &block)
     end
     
@@ -45,7 +43,7 @@ module Sequel
       execute_dui(sql, opts, &block)
     end
 
-    # Method that should be used when issuing a DELETE, UPDATE, or INSERT
+    # Method that should be used when issuing a DELETE or UPDATE
     # statement.  By default, calls execute.
     # This method should not be called directly by user code.
     def execute_dui(sql, opts=OPTS, &block)
@@ -59,11 +57,11 @@ module Sequel
       execute_dui(sql, opts, &block)
     end
 
-    # Returns a single value from the database, e.g.:
+    # Returns a single value from the database, see Dataset#get.
     #
     #   DB.get(1) # SELECT 1
     #   # => 1
-    #   DB.get{server_version{}} # SELECT server_version()
+    #   DB.get{server_version.function} # SELECT server_version()
     def get(*args, &block)
       @default_dataset.get(*args, &block)
     end
@@ -88,7 +86,7 @@ module Sequel
     # :schema :: An explicit schema to use.  It may also be implicitly provided
     #            via the table name.
     #
-    # If schema parsing is supported by the database, the column information should hash at least contain the
+    # If schema parsing is supported by the database, the column information hash should contain at least the
     # following entries:
     #
     # :allow_null :: Whether NULL is an allowed value for the column.
@@ -159,7 +157,7 @@ module Sequel
       end
 
       cols = schema_parse_table(table_name, opts)
-      raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
+      raise(Error, "schema parsing returned no columns, table #{table_name.inspect} probably doesn't exist") if cols.nil? || cols.empty?
 
       primary_keys = 0
       auto_increment_set = false
@@ -178,6 +176,8 @@ module Sequel
           c[:max_length] = max_length
         end
       end
+      schema_post_process(cols)
+
       Sequel.synchronize{@schemas[quoted_name] = cols} if cache_schema
       cols
     end
@@ -236,11 +236,11 @@ module Sequel
       when :date
         Sequel.string_to_date(default)
       when :datetime
-        DateTime.parse(default)
+        Sequel.string_to_datetime(default)
       when :time
         Sequel.string_to_time(default)
       when :decimal
-        BigDecimal.new(default)
+        BigDecimal(default)
       end
     end
    
@@ -248,7 +248,7 @@ module Sequel
     # and return the normalized value.
     def column_schema_normalize_default(default, type)
       if column_schema_default_string_type?(type)
-        return unless m = STRING_DEFAULT_RE.match(default)
+        return unless m = /\A'(.*)'\z/.match(default)
         m[1].gsub("''", "'")
       else
         default
@@ -260,7 +260,7 @@ module Sequel
     def column_schema_to_ruby_default(default, type)
       return default unless default.is_a?(String)
       if COLUMN_SCHEMA_DATETIME_TYPES.include?(type)
-        if CURRENT_TIMESTAMP_RE.match(default)
+        if /now|today|CURRENT|getdate|\ADate\(\)\z/i.match(default)
           if type == :date
             return Sequel::CURRENT_DATE
           else
@@ -287,16 +287,16 @@ module Sequel
       (ds || dataset).method(:input_identifier)
     end
     
+    # Uncached version of metadata_dataset, designed for overriding.
+    def _metadata_dataset
+      dataset
+    end
+
     # Return a dataset that uses the default identifier input and output methods
     # for this database.  Used when parsing metadata so that column symbols are
     # returned as expected.
     def metadata_dataset
-      @metadata_dataset ||= (
-        ds = dataset;
-        ds.identifier_input_method = identifier_input_method_default;
-        ds.identifier_output_method = identifier_output_method_default;
-        ds
-      )
+      @metadata_dataset ||= _metadata_dataset
     end
 
     # Return a Method object for the dataset's output_identifier_method.
@@ -308,10 +308,10 @@ module Sequel
 
     # Remove the cached schema for the given schema name
     def remove_cached_schema(table)
-      if @schemas
-        k = quote_schema_table(table)
-        Sequel.synchronize{@schemas.delete(k)}
-      end
+      cache = @default_dataset.send(:cache)
+      Sequel.synchronize{cache.clear}
+      k = quote_schema_table(table)
+      Sequel.synchronize{@schemas.delete(k)}
     end
     
     # Match the database's column type to a ruby type via a
@@ -325,13 +325,13 @@ module Sequel
         :integer
       when /\Adate\z/io
         :date
-      when /\A((small)?datetime|timestamp( with(out)? time zone)?)(\(\d+\))?\z/io
+      when /\A((small)?datetime|timestamp(\(\d\))?( with(out)? time zone)?)\z/io
         :datetime
       when /\Atime( with(out)? time zone)?\z/io
         :time
       when /\A(bool(ean)?)\z/io
         :boolean
-      when /\A(real|float|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
+      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
       when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?))\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
@@ -341,5 +341,25 @@ module Sequel
         :enum
       end
     end
+
+    # Post process the schema values.  
+    def schema_post_process(cols)
+      # :nocov:
+      if RUBY_VERSION >= '2.5'
+      # :nocov:
+        cols.each do |_, h|
+          db_type = h[:db_type]
+          if db_type.is_a?(String)
+            h[:db_type] = -db_type
+          end
+        end
+      end
+
+      cols.each do |_,c|
+        c.each_value do |val|
+          val.freeze if val.is_a?(String)
+        end
+      end
+    end
   end
 end