sequel 5.83.0 → 5.106.0

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

@@ -95,14 +95,14 @@ module Sequel
         metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
           if opts[:only_autocreated]
             # If specifically asked for only autocreated indexes, then return those an only those
-            next unless r[:name] =~ /\Asqlite_autoindex_/
+            next unless r[:name].start_with?('sqlite_autoindex_')
           elsif r.has_key?(:origin)
             # If origin is set, then only exclude primary key indexes and partial indexes
             next if r[:origin] == 'pk'
             next if r[:partial].to_i == 1
           else
             # When :origin key not present, assume any autoindex could be a primary key one and exclude it
-            next if r[:name] =~ /\Asqlite_autoindex_/
+            next if r[:name].start_with?('sqlite_autoindex_')
           end
 
           indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
@@ -195,7 +195,7 @@ module Sequel
 
       # Dataset used for parsing schema
       def _parse_pragma_ds(table_name, opts)
-        metadata_dataset.with_sql("PRAGMA table_#{'x' if sqlite_version > 33100}info(?)", input_identifier_meth(opts[:dataset]).call(table_name))
+        metadata_dataset.with_sql("PRAGMA table_#{'x' if sqlite_version > 33100}info(?)".freeze, input_identifier_meth(opts[:dataset]).call(table_name))
       end
 
       # Run all alter_table commands in a transaction.  This is technically only
@@ -302,7 +302,7 @@ module Sequel
 
       # A name to use for the backup table
       def backup_table_name(table, opts=OPTS)
-        table = table.gsub('`', '')
+        table = table.delete('`')
         (opts[:times]||1000).times do |i|
           table_name = "#{table}_backup#{i}"
           return table_name unless table_exists?(table_name)
@@ -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
@@ -405,7 +407,7 @@ module Sequel
       def defined_columns_for(table)
         cols = parse_pragma(table, OPTS)
         cols.each do |c|
-          c[:default] = LiteralString.new(c[:default]) if c[:default]
+          c[:default] = LiteralString.new(c[:default]).freeze if c[:default]
           c[:type] = c[:db_type]
         end
         cols
@@ -682,7 +684,7 @@ module Sequel
         # Load the PrettyTable class, needed for explain output
         Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
 
-        ds = db.send(:metadata_dataset).clone(:sql=>"EXPLAIN #{select_sql}")
+        ds = db.send(:metadata_dataset).clone(:sql=>"EXPLAIN #{select_sql}".freeze)
         rows = ds.all
         Sequel::PrettyTable.string(rows, ds.columns)
       end

data/lib/sequel/adapters/sqlite.rb

@@ -89,8 +89,22 @@ module Sequel
       
       # Mimic the file:// uri, by having 2 preceding slashes specify a relative
       # path, and 3 preceding slashes specify an absolute path.
+      # Also support no preceding slashes to specify a relative path.
       def self.uri_to_options(uri) # :nodoc:
-        { :database => (uri.host.nil? && uri.path == '/') ? nil : "#{uri.host}#{uri.path}" }
+        database = if uri.host.nil?
+          case uri.path
+          when '/'
+            nil
+          when nil
+            uri.opaque
+          else
+            uri.path
+          end
+        else
+          "#{uri.host}#{uri.path}"
+        end
+
+        { :database => database }
       end
       
       private_class_method :uri_to_options
@@ -109,6 +123,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 +144,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)))
 
@@ -370,7 +388,7 @@ module Sequel
         # SQLite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
-          LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
+          LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}".freeze)
         end
       end
       

data/lib/sequel/adapters/tinytds.rb

@@ -14,7 +14,7 @@ module Sequel
         opts = server_opts(server)
         opts[:username] = opts[:user]
         c = TinyTds::Client.new(opts)
-        c.query_options.merge!(:cache_rows=>false)
+        c.query_options[:cache_rows] = false
 
         # SEQUEL6: Default to ansi: true
         if opts[:ansi]
@@ -205,7 +205,7 @@ module Sequel
         private
         
         def prepared_arg(k)
-          LiteralString.new("@#{k.to_s.gsub('.', '__')}")
+          LiteralString.new("@#{k.to_s.gsub('.', '__')}".freeze)
         end
       end
       

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
@@ -84,7 +83,7 @@ module Sequel
 
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+        db_type.start_with?("tinyint(1)") ? :boolean : super
       end
     end
 

data/lib/sequel/ast_transformer.rb

@@ -26,6 +26,8 @@ module Sequel
         h = {}
         o.each{|k, val| h[v(k)] = v(val)}
         h
+      when Set
+        Set.new(o.map{|x| v(x)})
       when SQL::NumericExpression
         if o.op == :extract
           o.class.new(o.op, o.args[0], v(o.args[1]))

data/lib/sequel/connection_pool/sharded_timed_queue.rb

@@ -71,7 +71,7 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
       while true
         conn = nil
         begin
-          break unless (conn = queue.pop(timeout: 0)) && !conns[conn]
+          break unless (conn = available(queue, server)) && !conns[conn]
           conns[conn] = true
           yield conn
         ensure
@@ -91,14 +91,16 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
   # creates new connections to the database.
   #
   # If the :server option is provided, it should be a symbol or array of symbols,
-  # and then the method will only disconnect connectsion from those specified shards.
+  # and then the method will only disconnect connections from those specified shards.
   def disconnect(opts=OPTS)
     (opts[:server] ? Array(opts[:server]) : sync{@servers.keys}).each do |server|
       raise Sequel::Error, "invalid server" unless queue = sync{@queues[server]}
-      while conn = queue.pop(timeout: 0)
+      nconns = 0
+      while conn = available(queue, server)
+        nconns += 1
         disconnect_pool_connection(conn, server)
       end
-      fill_queue(server)
+      fill_queue(server, nconns)
     end
     nil
   end
@@ -132,7 +134,7 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
         conn = nil
         disconnect_pool_connection(oconn, server) if oconn
         sync{@allocated[server].delete(t)}
-        fill_queue(server)
+        fill_queue(server, 1)
       end
       raise
     ensure
@@ -140,6 +142,12 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # The number of threads waiting to check out a connection for the given
+  # server.
+  def num_waiting(server=:default)
+    @queues[pick_server(server)].num_waiting
+  end
+
   # The total number of connections in the pool. Using a non-existant server will return nil.
   def size(server=:default)
     sync{@sizes[server]}
@@ -161,7 +169,7 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
 
         queue = @queues[server]
 
-        while conn = queue.pop(timeout: 0)
+        while conn = available(queue, server)
           @sizes[server] -= 1
           conns << conn
         end
@@ -219,6 +227,12 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
     conns.each{|conn| disconnect_connection(conn)}
   end
 
+  # Only for use by extension that need to disconnect a connection inside acquire.
+  # Takes the connection and any arguments accepted by acquire.
+  def disconnect_acquired_connection(conn, _, server)
+    disconnect_pool_connection(conn, server)
+  end
+
   # Decrement the current size of the pool for the server when disconnecting connections.
   #
   # Calling code should not have the mutex when calling this.
@@ -238,11 +252,15 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
   # after disconnecting to potentially add new connections to the
   # pool, so the threads that are currently waiting for connections
   # do not timeout after the pool is no longer full.
-  def fill_queue(server)
+  #
+  # nconns specifies the maximum number of connections to add, which should
+  # be the number of connections that were disconnected.
+  def fill_queue(server, nconns)
     queue = sync{@queues[server]}
-    if queue.num_waiting > 0
+    if nconns > 0 && queue.num_waiting > 0
       Thread.new do
-        while queue.num_waiting > 0 && (conn = try_make_new(server))
+        while nconns > 0 && queue.num_waiting > 0 && (conn = try_make_new(server))
+          nconns -= 1
           queue.push(conn)
         end
       end
@@ -291,7 +309,7 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
     ensure
       if to_disconnect
         to_disconnect.each{|conn| disconnect_pool_connection(conn, server)}
-        fill_queue(server)
+        fill_queue(server, to_disconnect.size)
       end
     end
   end
@@ -305,7 +323,7 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
   # Calling code should not have the mutex when calling this.
   def acquire(thread, server)
     queue = sync{@queues[server]}
-    if conn = queue.pop(timeout: 0) || try_make_new(server) || queue.pop(timeout: @timeout)
+    if conn = available(queue, server) || try_make_new(server) || wait_until_available(queue, server)
       sync{@allocated[server][thread] = conn}
     else
       name = db.opts[:name]
@@ -313,6 +331,19 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # Return the next connection in the pool if there is one available. Returns nil
+  # if no connection is currently available.
+  def available(queue, _server)
+    queue.pop(timeout: 0)
+  end
+
+  # Return the next connection in the pool if there is one available. If not, wait
+  # until the timeout for a connection to become available. If there is still no
+  # available connection, return nil.
+  def wait_until_available(queue, _server)
+    queue.pop(timeout: @timeout)
+  end
+
   # Returns the connection owned by the supplied thread for the given server,
   # if any. The calling code should NOT already have the mutex before calling this.
   def owned_connection(thread, server)

data/lib/sequel/connection_pool/timed_queue.rb

@@ -42,7 +42,7 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
       while true
         conn = nil
         begin
-          break unless (conn = @queue.pop(timeout: 0)) && !conns[conn]
+          break unless (conn = available) && !conns[conn]
           conns[conn] = true
           yield conn
         ensure
@@ -59,10 +59,12 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
   # Once a connection is requested using #hold, the connection pool
   # creates new connections to the database.
   def disconnect(opts=OPTS)
-    while conn = @queue.pop(timeout: 0)
+    nconns = 0
+    while conn = available
+      nconns += 1
       disconnect_connection(conn)
     end
-    fill_queue
+    fill_queue(nconns)
     nil
   end
 
@@ -94,7 +96,7 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
         conn = nil
         disconnect_connection(oconn) if oconn
         sync{@allocated.delete(t)}
-        fill_queue
+        fill_queue(1)
       end
       raise
     ensure
@@ -102,6 +104,11 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # The number of threads waiting to check out a connection.
+  def num_waiting(_server=:default)
+    @queue.num_waiting
+  end
+
   def pool_type
     :timed_queue
   end
@@ -151,10 +158,13 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
   # after disconnecting to potentially add new connections to the
   # pool, so the threads that are currently waiting for connections
   # do not timeout after the pool is no longer full.
-  def fill_queue
-    if @queue.num_waiting > 0
+  #
+  # nconns specifies the maximum number of connections to add, which should
+  # be the number of connections that were disconnected.
+  def fill_queue(nconns)
+    if nconns > 0 && @queue.num_waiting > 0
       Thread.new do
-        while @queue.num_waiting > 0 && (conn = try_make_new)
+        while nconns > 0 && @queue.num_waiting > 0 && (conn = try_make_new)
           @queue.push(conn)
         end
       end
@@ -202,7 +212,7 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
     ensure
       if to_disconnect
         to_disconnect.each{|conn| disconnect_connection(conn)}
-        fill_queue
+        fill_queue(to_disconnect.size)
       end
     end
   end
@@ -215,7 +225,7 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
   #
   # Calling code should not have the mutex when calling this.
   def acquire(thread)
-    if conn = @queue.pop(timeout: 0) || try_make_new || @queue.pop(timeout: @timeout)
+    if conn = available || try_make_new || wait_until_available
       sync{@allocated[thread] = conn}
     else
       name = db.opts[:name]
@@ -223,6 +233,19 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # Return the next connection in the pool if there is one available. Returns nil
+  # if no connection is currently available.
+  def available
+    @queue.pop(timeout: 0)
+  end
+
+  # Return the next connection in the pool if there is one available. If not, wait
+  # until the timeout for a connection to become available. If there is still no
+  # available connection, return nil.
+  def wait_until_available
+    @queue.pop(timeout: @timeout)
+  end
+
   # Returns the connection owned by the supplied thread,
   # if any. The calling code should NOT already have the mutex before calling this.
   def owned_connection(thread)
@@ -236,7 +259,7 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
   def preconnect(concurrent = false)
     if concurrent
       if times = sync{@max_size > (size = @size[0]) ? @max_size - size : false}
-        times.times.map{Thread.new{if conn = try_make_new; @queue.push(conn) end}}.map(&:value)
+        Array.new(times){Thread.new{if conn = try_make_new; @queue.push(conn) end}}.map(&:value)
       end
     else
       while conn = try_make_new

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
@@ -131,6 +131,12 @@ class Sequel::ConnectionPool
     db.disconnect_connection(conn)
   end
 
+  # Only for use by extension that need to disconnect a connection inside acquire.
+  # Takes the connection and any arguments accepted by acquire.
+  def disconnect_acquired_connection(conn, *)
+    disconnect_connection(conn)
+  end
+
   # Whether the given exception is a disconnect exception.
   def disconnect_error?(exception)
     exception.is_a?(Sequel::DatabaseDisconnectError) || db.send(:disconnect_error?, exception, OPTS)

data/lib/sequel/core.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-%w'bigdecimal date thread time uri'.each{|f| require f}
+%w'bigdecimal date set thread time uri'.each{|f| require f}
 
 # Top level module for Sequel
 #
@@ -164,6 +164,35 @@ module Sequel
       JSON::ParserError
     end
 
+    if RUBY_VERSION >= '3'
+      # Join the array or set.
+      def array_or_set_join(obj, arg)
+        obj.join(arg)
+      end
+    # :nocov:
+    else
+      def array_or_set_join(obj, arg)
+        obj = obj.to_a if obj.is_a?(Set)
+        obj.join(arg)
+      end
+    end
+    # :nocov:
+
+    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)
@@ -388,7 +417,7 @@ module Sequel
       when -1, 0
         vr.instance_exec(&block)
       else
-        block.call(vr)
+        yield(vr)
       end  
     end
 

data/lib/sequel/database/connecting.rb

@@ -34,7 +34,7 @@ module Sequel
           uri = URI.parse(conn_string)
           scheme = uri.scheme
           c = adapter_class(scheme)
-          opts = c.send(:uri_to_options, uri).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)

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,18 +26,23 @@ 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| }
 
     # 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
+    def self.after_initialize
+      raise Error, "must provide block to after_initialize" unless defined?(yield)
       Sequel.synchronize do
         previous = @initialize_hook
         @initialize_hook = proc do |db|
           previous.call(db)
-          block.call(db)
+          yield(db)
         end
       end
     end
@@ -72,18 +77,23 @@ module Sequel
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object. 
     def self.uri_to_options(uri)
-      uri_options = {
+      {
         :user => uri.user,
         :password => uri.password,
         :port => uri.port,
         :host => uri.hostname,
         :database => (m = /\/(.*)/.match(uri.path)) && (m[1])
       }
+    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::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
+      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 :uri_to_options
+    private_class_method :options_from_uri
 
     # The options hash for this database
     attr_reader :opts
@@ -106,6 +116,10 @@ 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
@@ -155,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
@@ -236,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
@@ -266,7 +284,7 @@ module Sequel
       keys = [:host, :database, :user]
       opts = self.opts
       if !keys.any?{|k| opts[k]} && opts[:uri]
-        opts = self.class.send(:uri_to_options, URI.parse(opts[:uri]))
+        opts = self.class.send(:options_from_uri, URI.parse(opts[:uri]))
       end
 
       keys.each do |key|
@@ -617,7 +635,7 @@ module Sequel
     # Typecast the value to a String
     def typecast_value_string(value)
       case value
-      when Hash, Array
+      when Hash, Array, Set
         raise Sequel::InvalidValue, "invalid value for String: #{value.inspect}"
       else
         value.to_s