sequel 5.60.1 → 5.81.0

data/lib/sequel/dataset/query.rb

@@ -12,6 +12,10 @@ module Sequel
     # in the extension).
     EXTENSIONS = {}
 
+    # Hash of extension name symbols to modules to load to implement the extension.
+    EXTENSION_MODULES = {}
+    private_constant :EXTENSION_MODULES
+
     EMPTY_ARRAY = [].freeze
 
     # The dataset options that require the removal of cached columns if changed.
@@ -39,18 +43,14 @@ module Sequel
       add_graph_aliases distinct except exclude exclude_having
       filter for_update from from_self graph grep group group_and_count group_append group_by having intersect invert
       limit lock_style naked offset or order order_append order_by order_more order_prepend qualify
-      reverse reverse_order select select_all select_append select_group select_more server
+      reverse reverse_order select select_all select_append select_group select_more select_prepend server
       set_graph_aliases unfiltered ungraphed ungrouped union
       unlimited unordered where with with_recursive with_sql
     METHS
 
     # Register an extension callback for Dataset objects.  ext should be the
-    # extension name symbol, and mod should either be a Module that the
-    # dataset is extended with, or a callable object called with the database
-    # object.  If mod is not provided, a block can be provided and is treated
-    # as the mod object.
-    #
-    # If mod is a module, this also registers a Database extension that will
+    # extension name symbol, and mod should be a Module that will be
+    # included in the dataset's class. This also registers a Database extension that will
     # extend all of the database's datasets.
     def self.register_extension(ext, mod=nil, &block)
       if mod
@@ -58,14 +58,20 @@ module Sequel
         if mod.is_a?(Module)
           block = proc{|ds| ds.extend(mod)}
           Sequel::Database.register_extension(ext){|db| db.extend_datasets(mod)}
+          Sequel.synchronize{EXTENSION_MODULES[ext] = mod}
         else
           block = mod
         end
       end
+
+      unless mod.is_a?(Module)
+        Sequel::Deprecation.deprecate("Providing a block or non-module to Sequel::Dataset.register_extension is deprecated and support for it will be removed in Sequel 6.")
+      end
+
       Sequel.synchronize{EXTENSIONS[ext] = block}
     end
 
-    # On Ruby 2.4+, use clone(:freeze=>false) to create clones, because
+    # On Ruby 2.4+, use clone(freeze: false) to create clones, because
     # we use true freezing in that case, and we need to modify the opts
     # in the frozen copy.
     #
@@ -116,13 +122,14 @@ module Sequel
     #  DB[:items].order(:id).distinct(:id) # SQL: SELECT DISTINCT ON (id) * FROM items ORDER BY id
     #  DB[:items].order(:id).distinct{func(:id)} # SQL: SELECT DISTINCT ON (func(id)) * FROM items ORDER BY id
     #
-    # There is support for emualting the DISTINCT ON support in MySQL, but it
+    # There is support for emulating the DISTINCT ON support in MySQL, but it
     # does not support the ORDER of the dataset, and also doesn't work in many
     # cases if the ONLY_FULL_GROUP_BY sql_mode is used, which is the default on
     # MySQL 5.7.5+.
     def distinct(*args, &block)
       virtual_row_columns(args, block)
       if args.empty?
+        return self if opts[:distinct] == EMPTY_ARRAY
         cached_dataset(:_distinct_ds){clone(:distinct => EMPTY_ARRAY)}
       else
         raise(InvalidOperation, "DISTINCT ON not supported") unless supports_distinct_on?
@@ -195,11 +202,15 @@ module Sequel
     if TRUE_FREEZE
       # Return a clone of the dataset loaded with the given dataset extensions.
       # If no related extension file exists or the extension does not have
-      # specific support for Dataset objects, an Error will be raised.
-      def extension(*a)
-        c = _clone(:freeze=>false)
-        c.send(:_extension!, a)
-        c.freeze
+      # specific support for Dataset objects, an error will be raised.
+      def extension(*exts)
+        Sequel.extension(*exts)
+        mods = exts.map{|ext| Sequel.synchronize{EXTENSION_MODULES[ext]}}
+        if mods.all?
+          with_extend(*mods)
+        else
+          with_extend(DeprecatedSingletonClassMethods).extension(*exts)
+        end
       end
     else
       # :nocov:
@@ -220,6 +231,7 @@ module Sequel
     #
     #   DB[:table].for_update # SELECT * FROM table FOR UPDATE
     def for_update
+       return self if opts[:lock] == :update
       cached_dataset(:_for_update_ds){lock_style(:update)}
     end
 
@@ -631,6 +643,7 @@ module Sequel
     #   DB.from(:a, DB[:b].where(Sequel[:a][:c]=>Sequel[:b][:d]).lateral)
     #   # SELECT * FROM a, LATERAL (SELECT * FROM b WHERE (a.c = b.d))
     def lateral
+      return self if opts[:lateral]
       cached_dataset(:_lateral_ds){clone(:lateral=>true)}
     end
 
@@ -734,6 +747,7 @@ module Sequel
     #   ds.all # => [{2=>:id}]
     #   ds.naked.all # => [{:id=>2}]
     def naked
+      return self unless opts[:row_proc]
       cached_dataset(:_naked_ds){with_row_proc(nil)}
     end
 
@@ -743,6 +757,7 @@ module Sequel
     #   DB[:items].for_update.nowait
     #   # SELECT * FROM items FOR UPDATE NOWAIT
     def nowait
+      return self if opts[:nowait]
       cached_dataset(:_nowait_ds) do
         raise(Error, 'This dataset does not support raises errors instead of waiting for locked rows') unless supports_nowait?
         clone(:nowait=>true)
@@ -787,7 +802,7 @@ module Sequel
     #   DB[:items].order(Sequel.lit('a + b')) # SELECT * FROM items ORDER BY a + b
     #   DB[:items].order(Sequel[:a] + :b) # SELECT * FROM items ORDER BY (a + b)
     #   DB[:items].order(Sequel.desc(:name)) # SELECT * FROM items ORDER BY name DESC
-    #   DB[:items].order(Sequel.asc(:name, :nulls=>:last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
+    #   DB[:items].order(Sequel.asc(:name, nulls: :last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
     #   DB[:items].order{sum(name).desc} # SELECT * FROM items ORDER BY sum(name) DESC
     #   DB[:items].order(nil) # SELECT * FROM items
     def order(*columns, &block)
@@ -857,17 +872,18 @@ module Sequel
     #   DB[:items].returning(nil) # RETURNING NULL
     #   DB[:items].returning(:id, :name) # RETURNING id, name
     #
-    #   DB[:items].returning.insert(:a=>1) do |hash|
+    #   DB[:items].returning.insert(a: 1) do |hash|
     #     # hash for each row inserted, with values for all columns
     #   end
-    #   DB[:items].returning.update(:a=>1) do |hash|
+    #   DB[:items].returning.update(a: 1) do |hash|
     #     # hash for each row updated, with values for all columns
     #   end
-    #   DB[:items].returning.delete(:a=>1) do |hash|
+    #   DB[:items].returning.delete(a: 1) do |hash|
     #     # hash for each row deleted, with values for all columns
     #   end
     def returning(*values)
       if values.empty?
+        return self if opts[:returning] == EMPTY_ARRAY
         cached_dataset(:_returning_ds) do
           raise Error, "RETURNING is not supported on #{db.database_type}" unless supports_returning?(:insert)
           clone(:returning=>EMPTY_ARRAY)
@@ -920,6 +936,7 @@ module Sequel
     #   DB[:items].select_all(:items, :foo) # SELECT items.*, foo.* FROM items
     def select_all(*tables)
       if tables.empty?
+        return self unless opts[:select]
         cached_dataset(:_select_all_ds){clone(:select => nil)}
       else
         select(*tables.map{|t| i, a = split_alias(t); a || i}.map!{|t| SQL::ColumnAll.new(t)}.freeze)
@@ -934,14 +951,8 @@ module Sequel
     #   DB[:items].select(:a).select_append(:b) # SELECT a, b FROM items
     #   DB[:items].select_append(:b) # SELECT *, b FROM items
     def select_append(*columns, &block)
-      cur_sel = @opts[:select]
-      if !cur_sel || cur_sel.empty?
-        unless supports_select_all_and_column?
-          return select_all(*(Array(@opts[:from]) + Array(@opts[:join]))).select_append(*columns, &block)
-        end
-        cur_sel = [WILDCARD]
-      end
-      select(*(cur_sel + columns), &block)
+      virtual_row_columns(columns, block)
+      select(*(_current_select(true) + columns))
     end
 
     # Set both the select and group clauses with the given +columns+.
@@ -963,6 +974,18 @@ module Sequel
       select_append(*columns, &block)
     end
     
+    # Returns a copy of the dataset with the given columns added
+    # to the existing selected columns.  If no columns are currently selected,
+    # it will select the columns given in addition to *.
+    #
+    #   DB[:items].select(:a).select(:b) # SELECT b FROM items
+    #   DB[:items].select(:a).select_prepend(:b) # SELECT b, a FROM items
+    #   DB[:items].select_prepend(:b) # SELECT b, * FROM items
+    def select_prepend(*columns, &block)
+      virtual_row_columns(columns, block)
+      select(*(columns + _current_select(false)))
+    end
+
     # Set the server for this dataset to use.  Used to pick a specific database
     # shard to run a query against, or to override the default (where SELECT uses
     # :read_only database and all other queries use the :default database).  This
@@ -989,6 +1012,7 @@ module Sequel
 
     # Specify that the check for limits/offsets when updating/deleting be skipped for the dataset.
     def skip_limit_check
+      return self if opts[:skip_limit_check]
       cached_dataset(:_skip_limit_check_ds) do
         clone(:skip_limit_check=>true)
       end
@@ -996,6 +1020,7 @@ module Sequel
 
     # Skip locked rows when returning results from this dataset.
     def skip_locked
+      return self if opts[:skip_locked]
       cached_dataset(:_skip_locked_ds) do
         raise(Error, 'This dataset does not support skipping locked rows') unless supports_skip_locked?
         clone(:skip_locked=>true)
@@ -1007,6 +1032,7 @@ module Sequel
     #   DB[:items].group(:a).having(a: 1).where(:b).unfiltered
     #   # SELECT * FROM items GROUP BY a
     def unfiltered
+      return self unless opts[:where] || opts[:having]
       cached_dataset(:_unfiltered_ds){clone(:where => nil, :having => nil)}
     end
 
@@ -1015,6 +1041,7 @@ module Sequel
     #   DB[:items].group(:a).having(a: 1).where(:b).ungrouped
     #   # SELECT * FROM items WHERE b
     def ungrouped
+      return self unless opts[:group] || opts[:having]
       cached_dataset(:_ungrouped_ds){clone(:group => nil, :having => nil)}
     end
 
@@ -1042,6 +1069,7 @@ module Sequel
     # 
     #   DB[:items].limit(10, 20).unlimited # SELECT * FROM items
     def unlimited
+      return self unless opts[:limit] || opts[:offset]
       cached_dataset(:_unlimited_ds){clone(:limit=>nil, :offset=>nil)}
     end
 
@@ -1049,6 +1077,7 @@ module Sequel
     # 
     #   DB[:items].order(:a).unordered # SELECT * FROM items
     def unordered
+      return self unless opts[:order]
       cached_dataset(:_unordered_ds){clone(:order=>nil)}
     end
     
@@ -1102,7 +1131,7 @@ module Sequel
     # referenced in window functions. See Sequel::SQL::Window for a list of
     # options that can be passed in. Example:
     #
-    #   DB[:items].window(:w, :partition=>:c1, :order=>:c2)
+    #   DB[:items].window(:w, partition: :c1, order: :c2)
     #   # SELECT * FROM items WINDOW w AS (PARTITION BY c1 ORDER BY c2)
     def window(name, opts)
       clone(:window=>((@opts[:window]||EMPTY_ARRAY) + [[name, SQL::Window.new(opts)].freeze]).freeze)
@@ -1163,7 +1192,7 @@ module Sequel
     #   DB[:t].with_recursive(:t,
     #     DB[:i1].select(:id, :parent_id).where(parent_id: nil),
     #     DB[:i1].join(:t, id: :parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]),
-    #     :args=>[:id, :parent_id])
+    #     args: [:id, :parent_id])
     #   
     #   # WITH RECURSIVE t(id, parent_id) AS (
     #   #   SELECT id, parent_id FROM i1 WHERE (parent_id IS NULL)
@@ -1199,16 +1228,27 @@ module Sequel
     end
     
     if TRUE_FREEZE
-      # Return a clone of the dataset extended with the given modules.
+      # Create a subclass of the receiver's class, and include the given modules
+      # into it. If a block is provided, a DatasetModule is created using the block and
+      # is included into the subclass.  Create an instance of the subclass using the
+      # same db and opts, so that the returned dataset operates similarly to a clone
+      # extended with the given modules.  This approach is used to avoid singleton
+      # classes, which significantly improves performance.
+      #
       # Note that like Object#extend, when multiple modules are provided
-      # as arguments the cloned dataset is extended with the modules in reverse
-      # order.  If a block is provided, a DatasetModule is created using the block and
-      # the clone is extended with that module after any modules given as arguments.
+      # as arguments the subclass includes the modules in reverse order.
       def with_extend(*mods, &block)
-        c = _clone(:freeze=>false)
-        c.extend(*mods) unless mods.empty?
-        c.extend(DatasetModule.new(&block)) if block
-        c.freeze
+        c = Class.new(self.class)
+        c.include(*mods) unless mods.empty?
+        c.include(DatasetModule.new(&block)) if block
+        o = c.freeze.allocate
+        o.instance_variable_set(:@db, @db)
+        o.instance_variable_set(:@opts, @opts)
+        o.instance_variable_set(:@cache, {})
+        if cols = cache_get(:_columns)
+          o.send(:columns=, cols)
+        end
+        o.freeze
       end
     else
       # :nocov:
@@ -1241,7 +1281,7 @@ module Sequel
     #
     # You can also provide a method name and arguments to call to get the SQL:
     #
-    #   DB[:items].with_sql(:insert_sql, :b=>1) # INSERT INTO items (b) VALUES (1)
+    #   DB[:items].with_sql(:insert_sql, b: 1) # INSERT INTO items (b) VALUES (1)
     #
     # Note that datasets that specify custom SQL using this method will generally
     # ignore future dataset methods that modify the SQL used, as specifying custom SQL
@@ -1315,17 +1355,51 @@ module Sequel
 
     private
 
-    # Load the extensions into the receiver, without checking if the receiver is frozen.
-    def _extension!(exts)
-      Sequel.extension(*exts)
-      exts.each do |ext|
-        if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          pr.call(self)
+    # :nocov:
+    unless TRUE_FREEZE
+      # Load the extensions into the receiver, without checking if the receiver is frozen.
+      def _extension!(exts)
+        Sequel.extension(*exts)
+        exts.each do |ext|
+          if pr = Sequel.synchronize{EXTENSIONS[ext]}
+            pr.call(self)
+          else
+            raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
+          end
+        end
+        self
+      end
+    end
+    # :nocov:
+
+    # A frozen array for the currently selected columns.
+    def _current_select(allow_plain_wildcard)
+      cur_sel = @opts[:select]
+
+      if !cur_sel || cur_sel.empty?
+        cur_sel = if allow_plain_wildcard && supports_select_all_and_column?
+          [WILDCARD].freeze
         else
-          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
+          _current_select_column_all
         end
+      elsif !allow_plain_wildcard && cur_sel.include?(WILDCARD)
+        cur_sel = cur_sel.dup
+        index = cur_sel.index(WILDCARD)
+        cur_sel.delete(WILDCARD)
+        _current_select_column_all.each_with_index do |ca, i|
+          cur_sel.insert(index+i, ca)
+        end
+        cur_sel.freeze
       end
-      self
+
+      cur_sel
+    end
+
+    # An array of SQL::ColumnAll objects for all FROM and JOIN tables.  Used for select_append
+    # and select_prepend.
+    def _current_select_column_all
+      tables = Array(@opts[:from]) + Array(@opts[:join])
+      tables.map{|t| i, a = split_alias(t); a || i}.map!{|t| SQL::ColumnAll.new(t)}.freeze
     end
 
     # If invert is true, invert the condition.

data/lib/sequel/dataset/sql.rb

@@ -82,7 +82,7 @@ module Sequel
       when DateTime
         literal_datetime_append(sql, v)
       when Date
-        sql << literal_date(v)
+        literal_date_append(sql, v)
       when Dataset
         literal_dataset_append(sql, v)
       else
@@ -115,6 +115,33 @@ module Sequel
       sql
     end
 
+    # Literalize a date or time value, as a SQL string value with no
+    # typecasting. If +raw+ is true, remove the surrounding single
+    # quotes.  This is designed for usage by bound argument code that
+    # can work even if the auto_cast_date_and_time extension is
+    # used (either manually or implicitly in the related adapter).
+    def literal_date_or_time(dt, raw=false)
+      value = case dt
+      when SQLTime
+        literal_sqltime(dt)
+      when Time
+        literal_time(dt)
+      when DateTime
+        literal_datetime(dt)
+      when Date
+        literal_date(dt)
+      else
+        raise TypeError, "unsupported type: #{dt.inspect}"
+      end
+
+      if raw
+        value.sub!(/\A'/, '')
+        value.sub!(/'\z/, '')
+      end
+
+      value
+    end
+
     # Returns an array of insert statements for inserting multiple records.
     # This method is used by +multi_insert+ to format insert statements and
     # expects a keys array and and an array of value arrays.
@@ -977,7 +1004,12 @@ module Sequel
     # order if not. Also removes the row_proc, which isn't needed
     # for aggregate calculations.
     def aggregate_dataset
-      (options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered).naked
+      (aggreate_dataset_use_from_self? ? from_self : unordered).naked
+    end
+
+    # Whether to use from_self for an aggregate dataset.
+    def aggreate_dataset_use_from_self?
+      options_overlap(COUNT_FROM_SELF_OPTS)
     end
 
     # Append aliasing expression to SQL string.
@@ -1099,9 +1131,14 @@ module Sequel
       :"t#{number}"
     end
     
-    # The strftime format to use when literalizing the time.
+    # The strftime format to use when literalizing time (Sequel::SQLTime) values.
+    def default_time_format
+      "'%H:%M:%S.%6N'"
+    end
+
+    # The strftime format to use when literalizing timestamp (Time/DateTime) values.
     def default_timestamp_format
-      requires_sql_standard_datetimes? ? "TIMESTAMP '%Y-%m-%d %H:%M:%S%N%z'" : "'%Y-%m-%d %H:%M:%S%N%z'"
+      "'%Y-%m-%d %H:%M:%S.%6N'"
     end
 
     def delete_delete_sql(sql)
@@ -1164,43 +1201,23 @@ module Sequel
       {1 => ((op == :IN) ? 0 : 1)}
     end
     
-    # Format the timestamp based on the default_timestamp_format, with a couple
-    # of modifiers.  First, allow %N to be used for fractions seconds (if the
-    # database supports them), and override %z to always use a numeric offset
-    # of hours and minutes.
+    # Format the timestamp based on the default_timestamp_format.
     def format_timestamp(v)
-      v2 = db.from_application_timestamp(v)
-      fmt = default_timestamp_format.gsub(/%[Nz]/) do |m|
-        if m == '%N'
-          # Ruby 1.9 supports %N in timestamp formats, but Sequel has supported %N
-          # for longer in a different way, where the . is already appended and only 6
-          # decimal places are used by default.
-          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(1000000) : v.usec) if supports_timestamp_usecs?
-        else
-          if supports_timestamp_timezones?
-            # Would like to just use %z format, but it doesn't appear to work on Windows
-            # Instead, the offset fragment is constructed manually
-            minutes = (v2.is_a?(DateTime) ? v2.offset * 1440 : v2.utc_offset/60).to_i
-            format_timestamp_offset(*minutes.divmod(60))
-          end
-        end
-      end
-      v2.strftime(fmt)
+      db.from_application_timestamp(v).strftime(default_timestamp_format)
     end
     
-    # Return the SQL timestamp fragment to use for the timezone offset.
-    def format_timestamp_offset(hour, minute)
-      sprintf("%+03i%02i", hour, minute)
-    end
+    # :nocov:
 
     # Return the SQL timestamp fragment to use for the fractional time part.
     # Should start with the decimal point.  Uses 6 decimal places by default.
     def format_timestamp_usec(usec, ts=timestamp_precision)
+      # SEQUEL6: Remove
       unless ts == 6
         usec = usec/(10 ** (6 - ts))
       end
       sprintf(".%0#{ts}d", usec)
     end
+    # :nocov:
 
     # Append literalization of identifier to SQL string, considering regular strings
     # as SQL identifiers instead of SQL strings.
@@ -1342,11 +1359,12 @@ module Sequel
 
     # SQL fragment for Date, using the ISO8601 format.
     def literal_date(v)
-      if requires_sql_standard_datetimes?
-        v.strftime("DATE '%Y-%m-%d'")
-      else
-        v.strftime("'%Y-%m-%d'")
-      end
+      v.strftime("'%Y-%m-%d'")
+    end
+
+    # Append literalization of date to SQL string.
+    def literal_date_append(sql, v)
+      sql << literal_date(v)
     end
 
     # SQL fragment for DateTime
@@ -1409,7 +1427,7 @@ module Sequel
 
     # SQL fragment for Sequel::SQLTime, containing just the time part
     def literal_sqltime(v)
-      v.strftime("'%H:%M:%S#{format_timestamp_usec(v.usec, sqltime_precision) if supports_timestamp_usecs?}'")
+      v.strftime(default_time_format)
     end
 
     # Append literalization of Sequel::SQLTime to SQL string.
@@ -1725,7 +1743,7 @@ module Sequel
     # Append literalization of the subselect to SQL string.
     def subselect_sql_append(sql, ds)
       sds = subselect_sql_dataset(sql, ds)
-      sds.sql
+      subselect_sql_append_sql(sql, sds)
       unless sds.send(:cache_sql?)
         # If subquery dataset does not allow caching SQL,
         # then this dataset should not allow caching SQL.
@@ -1737,6 +1755,10 @@ module Sequel
       ds.clone(:append_sql=>sql)
     end
 
+    def subselect_sql_append_sql(sql, ds)
+      ds.sql
+    end
+
     # The number of decimal digits of precision to use in timestamps.
     def timestamp_precision
       supports_timestamp_usecs? ? 6 : 0

data/lib/sequel/dataset.rb

@@ -53,4 +53,8 @@ module Sequel
   require_relative "dataset/sql"
   require_relative "dataset/placeholder_literalizer"
   require_relative "dataset/dataset_module"
+
+  # :nocov:
+  require_relative "dataset/deprecated_singleton_class_methods" if Dataset::TRUE_FREEZE
+  # :nocov:
 end

data/lib/sequel/exceptions.rb

@@ -18,6 +18,11 @@ module Sequel
       end
     end
   end  
+
+  (
+  # Error raised when there is a failed attempt to acquire an advisory lock.
+  AdvisoryLockError = Class.new(Error)
+  ).name
     
   (
   # Error raised when the adapter requested doesn't exist or can't be loaded.

data/lib/sequel/extensions/_model_pg_row.rb

@@ -23,18 +23,6 @@ module Sequel
             super
           end
         end
-
-        private
-
-        # Handle Sequel::Model instances in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when Sequel::Model
-            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/sequel/extensions/_pretty_table.rb

@@ -39,7 +39,7 @@ module Sequel
 
     # Hash of the maximum size of the value for each column 
     def self.column_sizes(records, columns) # :nodoc:
-      sizes = Hash.new {0}
+      sizes = Hash.new(0)
       columns.each do |c|
         sizes[c] = c.to_s.size
       end

data/lib/sequel/extensions/any_not_empty.rb

@@ -32,8 +32,8 @@
 module Sequel
   module AnyNotEmpty
     # If a block is not given, return whether the dataset is not empty.
-    def any?
-      if defined?(yield)
+    def any?(*a)
+      if !a.empty? || defined?(yield)
         super
       else
         !empty?

data/lib/sequel/extensions/async_thread_pool.rb

@@ -5,9 +5,9 @@
 # code
 #
 #   DB.extension :async_thread_pool
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bar].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #
 # All 3 queries will be run in separate threads.  +foos+, +bar_names+
 # and +baz_1+ will be proxy objects.  Calling a method on the proxy
@@ -15,9 +15,9 @@
 # of calling that method on the result of the query method. For example,
 # if you run:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bars].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #   sleep(1)
 #   foos.size
 #   bar_names.first
@@ -26,9 +26,9 @@
 # These three queries will generally be run concurrently in separate
 # threads.  If you instead run:
 #   
-#   DB[:foos].async.where{:name=>'A'..'M'}.all.size
+#   DB[:foos].async.where(name: 'A'..'M').all.size
 #   DB[:bars].async.select_order_map(:name).first
-#   DB[:bazes].async.first(:id=>1).name
+#   DB[:bazes].async.first(id: 1).name
 #
 # Then will run each query sequentially, since you need the result of
 # one query before running the next query.  The queries will still be
@@ -37,11 +37,11 @@
 # What is run in the separate thread is the entire method call that
 # returns results.  So with the original example:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bars].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #
-# The +all+, <tt>select_order_map(:name)</tt>, and <tt>first(:id=>1)</tt>
+# The +all+, <tt>select_order_map(:name)</tt>, and <tt>first(id: 1)</tt>
 # calls are run in separate threads.  If a block is passed to a method
 # such as +all+ or +each+, the block is also run in that thread.  If you
 # have code such as:
@@ -156,10 +156,10 @@
 # so that the query will run in the current thread instead of waiting
 # for an async thread to become available.  With the following code:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bar].async.select_order_map(:name)
 #   if foos.length > 4
-#     baz_1 = DB[:bazes].async.first(:id=>1)
+#     baz_1 = DB[:bazes].async.first(id: 1)
 #   end
 # 
 # Whether you need the +baz_1+ variable depends on the value of foos.
@@ -176,6 +176,13 @@
 # +:preempt_async_thread+ Database option before loading the
 # async_thread_pool extension.
 #
+# Note that the async_thread_pool extension creates the thread pool
+# when it is loaded into the Database.  If you fork after loading
+# the extension, the extension will not work, as fork does not
+# copy the thread pools.  If you are using a forking webserver
+# (or any other system that forks worker processes), load this
+# extension in each child process, do not load it before forking.
+#
 # Related module: Sequel::Database::AsyncThreadPool::DatasetMethods
 
 
@@ -338,8 +345,9 @@ module Sequel
     module DatabaseMethods
       def self.extended(db)
         db.instance_exec do
-          unless pool.pool_type == :threaded || pool.pool_type == :sharded_threaded
-            raise Error, "can only load async_thread_pool extension if using threaded or sharded_threaded connection pool"
+          case pool.pool_type
+          when :single, :sharded_single
+            raise Error, "cannot load async_thread_pool extension if using single or sharded_single connection pool"
           end
 
           num_async_threads = opts[:num_async_threads] ? typecast_value_integer(opts[:num_async_threads]) : (Integer(opts[:max_connections] || 4))