sequel 5.80.0 → 5.92.0

data/lib/sequel/adapters/shared/postgres.rb

@@ -1075,6 +1075,7 @@ module Sequel
               pg_attribute[:attname].as(:name),
               SQL::Cast.new(pg_attribute[:atttypid], :integer).as(:oid),
               SQL::Cast.new(basetype[:oid], :integer).as(:base_oid),
+              SQL::Function.new(:col_description, pg_class[:oid], pg_attribute[:attnum]).as(:comment),
               SQL::Function.new(:format_type, basetype[:oid], pg_type[:typtypmod]).as(:db_base_type),
               SQL::Function.new(:format_type, pg_type[:oid], pg_attribute[:atttypmod]).as(:db_type),
               SQL::Function.new(:pg_get_expr, pg_attrdef[:adbin], pg_class[:oid]).as(:default),
@@ -1270,21 +1271,32 @@ module Sequel
 
       # Handle exclusion constraints.
       def constraint_definition_sql(constraint)
-        case constraint[:type]
+        case type = constraint[:type]
         when :exclude
           elements = constraint[:elements].map{|c, op| "#{literal(c)} WITH #{op}"}.join(', ')
           sql = String.new
           sql << "#{"CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]}EXCLUDE USING #{constraint[:using]||'gist'} (#{elements})#{" WHERE #{filter_expr(constraint[:where])}" if constraint[:where]}"
           constraint_deferrable_sql_append(sql, constraint[:deferrable])
           sql
-        when :foreign_key, :check
+        when :primary_key, :unique
+          if using_index = constraint[:using_index]
+            sql = String.new
+            sql << "CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]
+            if type == :primary_key
+              sql << primary_key_constraint_sql_fragment(constraint)
+            else
+              sql << unique_constraint_sql_fragment(constraint)
+            end
+            sql << " USING INDEX " << quote_identifier(using_index)
+          else
+            super
+          end
+        else # when :foreign_key, :check
           sql = super
           if constraint[:not_valid]
             sql << " NOT VALID"
           end
           sql
-        else
-          super
         end
       end
 
@@ -1429,7 +1441,7 @@ module Sequel
           'UNLOGGED '
         end
 
-        "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
+        "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)}"
       end
 
       # SQL for creating a table with PostgreSQL specific options
@@ -1651,9 +1663,9 @@ module Sequel
       # Handle interval and citext types.
       def schema_column_type(db_type)
         case db_type
-        when /\Ainterval\z/io
+        when /\Ainterval\z/i
           :interval
-        when /\Acitext\z/io
+        when /\Acitext\z/i
           :string
         else
           super
@@ -2058,6 +2070,29 @@ module Sequel
         nil
       end
 
+      # Support MERGE RETURNING on PostgreSQL 17+.
+      def merge(&block)
+        sql = merge_sql
+        if uses_returning?(:merge)
+          returning_fetch_rows(sql, &block)
+        else
+          execute_ddl(sql)
+        end
+      end
+
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN DELETE clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_delete_not_matched_by_source
+      #   # WHEN NOT MATCHED BY SOURCE THEN DELETE
+      #
+      #   merge_delete_not_matched_by_source{a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN DELETE
+      def merge_delete_when_not_matched_by_source(&block)
+        _merge_when(:type=>:delete_not_matched_by_source, &block)
+      end
+
       # Return a dataset with a WHEN MATCHED THEN DO NOTHING clause added to the
       # MERGE statement.  If a block is passed, treat it as a virtual row and
       # use it as additional conditions for the match.
@@ -2084,15 +2119,41 @@ module Sequel
         _merge_when(:type=>:not_matched, &block)
       end
 
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN DO NOTHING clause added to the
+      # MERGE BY SOURCE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_do_nothing_when_not_matched_by_source
+      #   # WHEN NOT MATCHED BY SOURCE THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_not_matched_by_source{a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_not_matched_by_source(&block)
+        _merge_when(:type=>:not_matched_by_source, &block)
+      end
+
       # Support OVERRIDING USER|SYSTEM VALUE for MERGE INSERT.
       def merge_insert(*values, &block)
         h = {:type=>:insert, :values=>values}
-        if override = @opts[:override]
+        if @opts[:override]
           h[:override] = insert_override_sql(String.new)
         end
         _merge_when(h, &block)
       end
     
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN UPDATE clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_update_not_matched_by_source(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+      #   # WHEN NOT MATCHED BY SOURCE THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+      #
+      #   merge_update_not_matched_by_source(i1: :i2){a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN UPDATE SET i1 = i2
+      def merge_update_when_not_matched_by_source(values, &block)
+        _merge_when(:type=>:update_not_matched_by_source, :values=>values, &block)
+      end
+
       # Use OVERRIDING USER VALUE for INSERT statements, so that identity columns
       # always use the user supplied value, and an error is not raised for identity
       # columns that are GENERATED ALWAYS.
@@ -2170,9 +2231,14 @@ module Sequel
         true
       end
 
-      # Returning is always supported.
+      # MERGE RETURNING is supported on PostgreSQL 17+. Other RETURNING is supported
+      # on all supported PostgreSQL versions.
       def supports_returning?(type)
-        true
+        if type == :merge
+          server_version >= 170000
+        else
+          true
+        end
       end
 
       # PostgreSQL supports pattern matching via regular expressions
@@ -2281,7 +2347,7 @@ module Sequel
 
       # Append the INSERT sql used in a MERGE
       def _merge_insert_sql(sql, data)
-        sql << " THEN INSERT "
+        sql << " THEN INSERT"
         columns, values = _parse_insert_sql_args(data[:values])
         _insert_columns_sql(sql, columns)
         if override = data[:override]
@@ -2290,10 +2356,15 @@ module Sequel
         _insert_values_sql(sql, values)
       end
 
-      def _merge_matched_sql(sql, data)
+      def _merge_do_nothing_sql(sql, data)
         sql << " THEN DO NOTHING"
       end
-      alias _merge_not_matched_sql _merge_matched_sql
+
+      # Support MERGE RETURNING on PostgreSQL 17+.
+      def _merge_when_sql(sql)
+        super
+        insert_returning_sql(sql) if uses_returning?(:merge)
+      end
 
       # Format TRUNCATE statement with PostgreSQL specific options.
       def _truncate_sql(table)
@@ -2328,6 +2399,25 @@ module Sequel
         join_from_sql(:USING, sql)
       end
 
+      # Handle column aliases containing data types, useful for selecting from functions
+      # that return the record data type.
+      def derived_column_list_sql_append(sql, column_aliases)
+        c = false
+        comma = ', '
+        column_aliases.each do |a|
+          sql << comma if c
+          if a.is_a?(Array)
+            raise Error, "column aliases specified as arrays must have only 2 elements, the first is alias name and the second is data type" unless a.length == 2
+            a, type = a
+            identifier_append(sql, a)
+            sql << " " << db.cast_type_literal(type).to_s
+          else
+            identifier_append(sql, a)
+          end
+          c ||= true
+        end
+      end
+    
       # Add ON CONFLICT clause if it should be used
       def insert_conflict_sql(sql)
         if opts = @opts[:insert_conflict]
@@ -2371,6 +2461,9 @@ module Sequel
       # Return the primary key to use for RETURNING in an INSERT statement
       def insert_pk
         (f = opts[:from]) && !f.empty? && (t = f.first)
+
+        t = t.call(self) if t.is_a? Sequel::SQL::DelayedEvaluation
+
         case t
         when Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier
           if pk = db.primary_key(t)

data/lib/sequel/adapters/shared/sqlite.rb

@@ -245,7 +245,7 @@ module Sequel
             super
           end
         when :drop_column
-          if sqlite_version >= 33500
+          if sqlite_version >= 33500 && !indexes(table).any?{|_, h| h[:columns].include?(op[:name])}
             super
           else
             ocp = lambda{|oc| oc.delete_if{|c| c.to_s == op[:name].to_s}}
@@ -349,7 +349,7 @@ module Sequel
         ps
       end
 
-      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options
+      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options, and VIRTUAL tables with :using option.
       def create_table_sql(name, generator, options)
         if options[:strict] && options[:without_rowid]
           "#{super} STRICT, WITHOUT ROWID"
@@ -357,6 +357,8 @@ module Sequel
           "#{super} STRICT"
         elsif options[:without_rowid]
           "#{super} WITHOUT ROWID"
+        elsif options[:using]
+          "CREATE VIRTUAL TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)} USING #{options[:using]}"
         else
           super
         end

data/lib/sequel/adapters/sqlite.rb

@@ -109,6 +109,8 @@ module Sequel
       # :database :: database name (filename or ':memory:' or file: URI)
       # :readonly :: open database in read-only mode; useful for reading
       #              static data that you do not want to modify
+      # :disable_dqs :: disable double quoted strings in DDL and DML statements
+      #                 (requires SQLite 3.29.0+ and sqlite3 gem version 1.4.3+).
       # :timeout :: how long to wait for the database to be available if it
       #             is locked, given in milliseconds (default is 5000)
       # :setup_regexp_function :: enable use of Regexp objects with SQL
@@ -128,6 +130,8 @@ module Sequel
         opts[:database] = ':memory:' if blank_object?(opts[:database])
         sqlite3_opts = {}
         sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
+        # SEQUEL6: Make strict: true the default behavior
+        sqlite3_opts[:strict] = typecast_value_boolean(opts[:disable_dqs]) if opts.has_key?(:disable_dqs)
         db = ::SQLite3::Database.new(opts[:database].to_s, sqlite3_opts)
         db.busy_timeout(typecast_value_integer(opts.fetch(:timeout, 5000)))
 

data/lib/sequel/adapters/trilogy.rb

@@ -62,8 +62,7 @@ module Sequel
       private
 
       def database_specific_error_class(exception, opts)
-        case exception.message
-        when /1205 - Lock wait timeout exceeded; try restarting transaction\z/
+        if exception.error_code == 1205
           DatabaseLockTimeout
         else
           super

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -197,11 +197,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     timeout = @timeout
     timer = Sequel.start_timer
 
-    sync do
-      @waiters[server].wait(@mutex, timeout)
-      if conn = next_available(server)
-        return(allocated(server)[thread] = conn)
-      end
+    if conn = acquire_available(thread, server, timeout)
+      return conn
     end
 
     until conn = assign_connection(thread, server)
@@ -211,11 +208,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
 
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition variable
-      sync do
-        @waiters[server].wait(@mutex, timeout - elapsed)
-        if conn = next_available(server)
-          return(allocated(server)[thread] = conn)
-        end
+      if conn = acquire_available(thread, server, timeout - elapsed)
+        return conn
       end
       # :nocov:
     end
@@ -223,6 +217,28 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     conn
   end
 
+  # Acquire a connection if one is already available, or waiting until it becomes available.
+  def acquire_available(thread, server, timeout)
+    sync do
+      # Check if connection was checked in between when assign_connection failed and now.
+      # This is very unlikely, but necessary to prevent a situation where the waiter
+      # will wait for a connection even though one has already been checked in.
+      # :nocov:
+      if conn = next_available(server)
+        return(allocated(server)[thread] = conn)
+      end
+      # :nocov:
+
+      @waiters[server].wait(@mutex, timeout)
+
+      # Connection still not available, could be because a connection was disconnected,
+      # may have to retry assign_connection to see if a new connection can be made.
+      if conn = next_available(server)
+        return(allocated(server)[thread] = conn)
+      end
+    end
+  end
+
   # Assign a connection to the thread, or return nil if one cannot be assigned.
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread, server)

data/lib/sequel/connection_pool/threaded.rb

@@ -143,11 +143,8 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     timeout = @timeout
     timer = Sequel.start_timer
 
-    sync do
-      @waiter.wait(@mutex, timeout)
-      if conn = next_available
-        return(@allocated[thread] = conn)
-      end
+    if conn = acquire_available(thread, timeout)
+      return conn
     end
 
     until conn = assign_connection(thread)
@@ -157,11 +154,8 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
 
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition variable
-      sync do
-        @waiter.wait(@mutex, timeout - elapsed)
-        if conn = next_available
-          return(@allocated[thread] = conn)
-        end
+      if conn = acquire_available(thread, timeout - elapsed)
+        return conn
       end
       # :nocov:
     end
@@ -169,6 +163,28 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     conn
   end
 
+  # Acquire a connection if one is already available, or waiting until it becomes available.
+  def acquire_available(thread, timeout)
+    sync do
+      # Check if connection was checked in between when assign_connection failed and now.
+      # This is very unlikely, but necessary to prevent a situation where the waiter
+      # will wait for a connection even though one has already been checked in.
+      # :nocov:
+      if conn = next_available
+        return(@allocated[thread] = conn)
+      end
+      # :nocov:
+
+      @waiter.wait(@mutex, timeout)
+
+      # Connection still not available, could be because a connection was disconnected,
+      # may have to retry assign_connection to see if a new connection can be made.
+      if conn = next_available
+        return(@allocated[thread] = conn)
+      end
+    end
+  end
+
   # Assign a connection to the thread, or return nil if one cannot be assigned.
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread)

data/lib/sequel/connection_pool.rb

@@ -70,13 +70,13 @@ class Sequel::ConnectionPool
       else
         pc = if opts[:single_threaded]
           opts[:servers] ? :sharded_single : :single
-        # :nocov:
-        elsif RUBY_VERSION >= '3.4' # SEQUEL6 or maybe earlier switch to 3.2
+        elsif RUBY_VERSION >= '3.2'
           opts[:servers] ? :sharded_timed_queue : :timed_queue
         # :nocov:
         else
           opts[:servers] ? :sharded_threaded : :threaded
         end
+        # :nocov:
 
         connection_pool_class(:pool_class=>pc)
       end

data/lib/sequel/core.rb

@@ -164,6 +164,21 @@ module Sequel
       JSON::ParserError
     end
 
+    if RUBY_VERSION >= '3.3'
+      # Create a new module using the block, and set the temporary name
+      # on it using the given a containing module and name.
+      def set_temp_name(mod)
+        mod.set_temporary_name(yield)
+        mod
+      end
+    # :nocov:
+    else
+      def set_temp_name(mod)
+        mod
+      end
+    end
+    # :nocov:
+
     # Convert given object to json and return the result.
     # This can be overridden to use an alternative json implementation.
     def object_to_json(obj, *args, &block)

data/lib/sequel/database/connecting.rb

@@ -34,10 +34,7 @@ module Sequel
           uri = URI.parse(conn_string)
           scheme = uri.scheme
           c = adapter_class(scheme)
-          uri_options = c.send(:uri_to_options, uri)
-          uri.query.split('&').map{|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::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
-          opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
+          opts = c.send(:options_from_uri, uri).merge!(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash
         opts = conn_string.merge(opts)
@@ -270,28 +267,20 @@ module Sequel
       @single_threaded
     end
     
-    if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.5'
-    # :nocov:
-      def synchronize(server=nil)
-        @pool.hold(server || :default){|conn| yield conn}
-      end
-    # :nocov:
-    else
-      # Acquires a database connection, yielding it to the passed block. This is
-      # useful if you want to make sure the same connection is used for all
-      # database queries in the block.  It is also useful if you want to gain
-      # direct access to the underlying connection object if you need to do
-      # something Sequel does not natively support.
-      #
-      # If a server option is given, acquires a connection for that specific
-      # server, instead of the :default server.
-      #
-      #   DB.synchronize do |conn|
-      #     # ...
-      #   end
-      def synchronize(server=nil, &block)
-        @pool.hold(server || :default, &block)
-      end
+    # Acquires a database connection, yielding it to the passed block. This is
+    # useful if you want to make sure the same connection is used for all
+    # database queries in the block.  It is also useful if you want to gain
+    # direct access to the underlying connection object if you need to do
+    # something Sequel does not natively support.
+    #
+    # If a server option is given, acquires a connection for that specific
+    # server, instead of the :default server.
+    #
+    #   DB.synchronize do |conn|
+    #     # ...
+    #   end
+    def synchronize(server=nil, &block)
+      @pool.hold(server || :default, &block)
     end
     
     # Attempts to acquire a database connection.  Returns true if successful.
@@ -343,6 +332,11 @@ module Sequel
       else
         @opts.dup
       end
+
+      if pr = opts[:connect_opts_proc]
+        pr.call(opts)
+      end
+
       opts.delete(:servers)
       opts
     end

data/lib/sequel/database/dataset_defaults.rb

@@ -17,7 +17,7 @@ module Sequel
     # as the dataset class.
     def dataset_class=(c)
       unless @dataset_modules.empty?
-        c = Class.new(c)
+        c = Sequel.set_temp_name(Class.new(c)){"Sequel::Dataset::_Subclass"}
         @dataset_modules.each{|m| c.send(:include, m)}
       end
       @dataset_class = c
@@ -61,10 +61,10 @@ module Sequel
     #   # SELECT id, name FROM table WHERE active ORDER BY id
     def extend_datasets(mod=nil, &block)
       raise(Error, "must provide either mod or block, not both") if mod && block
-      mod = Dataset::DatasetModule.new(&block) if block
+      mod = Sequel.set_temp_name(Dataset::DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location[0,2].join(':')})"} if block
       if @dataset_modules.empty?
        @dataset_modules = [mod]
-       @dataset_class = Class.new(@dataset_class)
+       @dataset_class = Sequel.set_temp_name(Class.new(@dataset_class)){"Sequel::Dataset::_Subclass"}
       else
        @dataset_modules << mod
       end

data/lib/sequel/database/misc.rb

@@ -26,6 +26,11 @@ module Sequel
       :time=>Sequel::SQLTime, :boolean=>[TrueClass, FalseClass].freeze, :float=>Float, :decimal=>BigDecimal,
       :blob=>Sequel::SQL::Blob}.freeze
 
+    # :nocov:
+    URI_PARSER = defined?(::URI::RFC2396_PARSER) ? ::URI::RFC2396_PARSER : ::URI::DEFAULT_PARSER
+    # :nocov:
+    private_constant :URI_PARSER
+
     # Nested hook Proc; each new hook Proc just wraps the previous one.
     @initialize_hook = proc{|db| }
 
@@ -82,6 +87,14 @@ module Sequel
     end
     private_class_method :uri_to_options
 
+    def self.options_from_uri(uri)
+      uri_options = uri_to_options(uri)
+      uri.query.split('&').map{|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_PARSER.unescape(v) if v.is_a?(String)}
+      uri_options
+    end
+    private_class_method :options_from_uri
+
     # The options hash for this database
     attr_reader :opts
     
@@ -103,11 +116,18 @@ module Sequel
     # :after_connect :: A callable object called after each new connection is made, with the
     #                   connection object (and server argument if the callable accepts 2 arguments),
     #                   useful for customizations that you want to apply to all connections.
+    # :compare_connections_by_identity :: Whether to use compare_by_identity on hashes that use
+    #                                     connection objects as keys. Defaults to true. This should only
+    #                                     be set to false to work around bugs in libraries or
+    #                                     ruby implementations.
     # :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.
     # :connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
+    # :connect_opts_proc :: Callable object for modifying options hash used when connecting, designed for
+    #                       cases where the option values (e.g. password) are automatically rotated on
+    #                       a regular basis without involvement from the application using Sequel.
     # :default_string_column_size :: The default size of string columns, 255 by default.
     # :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
@@ -149,7 +169,7 @@ module Sequel
       @schemas = {}
       @prepared_statements = {}
       @transactions = {}
-      @transactions.compare_by_identity
+      @transactions.compare_by_identity if typecast_value_boolean(@opts.fetch(:compare_connections_by_identity, true))
       @symbol_literal_cache = {}
 
       @timezone = nil
@@ -230,9 +250,13 @@ module Sequel
     # extension does not have specific support for Database objects, an Error will be raised.
     # Returns self.
     def extension(*exts)
-      Sequel.extension(*exts)
       exts.each do |ext|
-        if pr = Sequel.synchronize{EXTENSIONS[ext]}
+        unless pr = Sequel.synchronize{EXTENSIONS[ext]}
+          Sequel.extension(ext)
+          pr = Sequel.synchronize{EXTENSIONS[ext]}
+        end
+
+        if pr
           if Sequel.synchronize{@loaded_extensions.include?(ext) ? false : (@loaded_extensions << ext)}
             pr.call(self)
           end
@@ -250,15 +274,27 @@ module Sequel
       Sequel.convert_output_timestamp(v, timezone)
     end
 
-    # Returns a string representation of the database object including the
-    # class name and connection URI and options used when connecting (if any).
+    # Returns a string representation of the Database object, including
+    # the database type, host, database, and user, if present.
     def inspect
-      a = []
-      a << uri.inspect if uri
-      if (oo = opts[:orig_opts]) && !oo.empty?
-        a << oo.inspect
+      s = String.new
+      s << "#<#{self.class}"
+      s << " database_type=#{database_type}" if database_type && database_type != adapter_scheme
+
+      keys = [:host, :database, :user]
+      opts = self.opts
+      if !keys.any?{|k| opts[k]} && opts[:uri]
+        opts = self.class.send(:options_from_uri, URI.parse(opts[:uri]))
       end
-      "#<#{self.class}: #{a.join(' ')}>"
+
+      keys.each do |key|
+        val = opts[key]
+        if val && val != ''
+          s << " #{key}=#{val}"
+        end
+      end
+
+      s << ">"
     end
 
     # Proxy the literal call to the dataset.

data/lib/sequel/database/query.rb

@@ -170,7 +170,7 @@ module Sequel
         c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type]) unless c.has_key?(:ruby_default)
         if c[:primary_key] && !auto_increment_set
           # If adapter didn't set it, assume that integer primary keys are auto incrementing
-          c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/io)
+          c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/i)
         end
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
@@ -390,25 +390,25 @@ module Sequel
     # such as :integer or :string.
     def schema_column_type(db_type)
       case db_type
-      when /\A(character( varying)?|n?(var)?char|n?text|string|clob)/io
+      when /\A(character( varying)?|n?(var)?char|n?text|string|clob)/i
         :string
-      when /\A(int(eger)?|(big|small|tiny)int)/io
+      when /\A(int(eger)?|(big|small|tiny)int)/i
         :integer
-      when /\Adate\z/io
+      when /\Adate\z/i
         :date
-      when /\A((small)?datetime|timestamp(\(\d\))?( with(out)? time zone)?)\z/io
+      when /\A((small)?datetime(\(\d\))?|timestamp(\(\d\))?( with(out)? time zone)?)\z/i
         :datetime
-      when /\Atime( with(out)? time zone)?\z/io
+      when /\Atime( with(out)? time zone)?\z/i
         :time
-      when /\A(bool(ean)?)\z/io
+      when /\A(bool(ean)?)\z/i
         :boolean
-      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
+      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/i
         :float
-      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/io
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/i
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
-      when /bytea|blob|image|(var)?binary/io
+      when /bytea|blob|image|(var)?binary/i
         :blob
-      when /\Aenum/io
+      when /\Aenum/i
         :enum
       end
     end