sequel 4.49.0 → 5.3.0

data/lib/sequel/dataset/actions.rb

@@ -12,12 +12,11 @@ module Sequel
     # Action methods defined by Sequel that execute code on the database.
     ACTION_METHODS = (<<-METHS).split.map(&:to_sym).freeze
       << [] all as_hash avg count columns columns! delete each
-      empty? fetch_rows first first! get import insert interval last
-      map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
+      empty? fetch_rows first first! get import insert last
+      map max min multi_insert paged_each select_hash select_hash_groups select_map select_order_map
       single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
       where_all where_each where_single_value
     METHS
-    # SEQUEL5: Remove interval, range
 
     # The clone options to use when retriveing columns for a dataset.
     COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
@@ -25,7 +24,7 @@ module Sequel
     # Inserts the given argument into the database.  Returns self so it
     # can be used safely when chaining:
     # 
-    #   DB[:items] << {:id=>0, :name=>'Zero'} << DB[:old_items].select(:id, name)
+    #   DB[:items] << {id: 0, name: 'Zero'} << DB[:old_items].select(:id, name)
     def <<(arg)
       insert(arg)
       self
@@ -33,8 +32,8 @@ module Sequel
     
     # Returns the first record matching the conditions. Examples:
     #
-    #   DB[:table][:id=>1] # SELECT * FROM table WHERE (id = 1) LIMIT 1
-    #   # => {:id=1}
+    #   DB[:table][id: 1] # SELECT * FROM table WHERE (id = 1) LIMIT 1
+    #   # => {:id=>1}
     def [](*conditions)
       raise(Error, 'You cannot call Dataset#[] with an integer or with no arguments') if (conditions.length == 1 and conditions.first.is_a?(Integer)) or conditions.length == 0
       first(*conditions)
@@ -92,6 +91,8 @@ module Sequel
       end
     end
     
+    COUNT_SELECT = Sequel.function(:count).*.as(:count)
+
     # Returns the number of records in the dataset. If an argument is provided,
     # it is used as the argument to count.  If a block is provided, it is
     # treated as a virtual row, and the result is used as the argument to
@@ -106,8 +107,7 @@ module Sequel
     def count(arg=(no_arg=true), &block)
       if no_arg && !block
         cached_dataset(:_count_ds) do
-          aggregate_dataset.select(Sequel.function(:count).*.as(:count)).single_value_ds
-          #aggregate_dataset.select(COUNT_SELECT).single_value_ds # SEQUEL5
+          aggregate_dataset.select(COUNT_SELECT).single_value_ds
         end.single_value!.to_i
       else
         if block
@@ -121,12 +121,8 @@ module Sequel
         _aggregate(:count, arg)
       end
     end
-    # SEQUEL5
-    #COUNT_SELECT = Sequel.function(:count).*.as(:count)
-    #private_constant :COUNT_SELECT
 
-    # Deletes the records in the dataset.  The returned value should be 
-    # number of records deleted, but that is adapter dependent.
+    # Deletes the records in the dataset, returning the number of records deleted.
     #
     #   DB[:table].delete # DELETE * FROM table
     #   # => 3
@@ -157,24 +153,22 @@ module Sequel
       self
     end
     
+    EMPTY_SELECT = Sequel::SQL::AliasedExpression.new(1, :one)
+
     # Returns true if no records exist in the dataset, false otherwise
     #
     #   DB[:table].empty? # SELECT 1 AS one FROM table LIMIT 1
     #   # => false
     def empty?
       cached_dataset(:_empty_ds) do
-        single_value_ds.unordered.select(Sequel::SQL::AliasedExpression.new(1, :one))
-        # single_value_ds.unordered.select(EMPTY_SELECT) # SEQUEL5
+        single_value_ds.unordered.select(EMPTY_SELECT)
       end.single_value!.nil?
     end
-    # SEQUEL5
-    #EMPTY_SELECT = Sequel::SQL::AliasedExpression.new(1, :one)
-    #private_constant :EMPTY_SELECT
 
+    # Returns the first matching record if no arguments are given.
     # If a integer argument is given, it is interpreted as a limit, and then returns all 
-    # matching records up to that limit.  If no argument is passed,
-    # it returns the first matching record.  If any other type of
-    # argument(s) is passed, it is given to filter and the
+    # matching records up to that limit.  If any other type of
+    # argument(s) is passed, it is treated as a filter and the
     # first matching record is returned.  If a block is given, it is used
     # to filter the dataset before returning anything.
     #
@@ -189,19 +183,19 @@ module Sequel
     #   DB[:table].first(2) # SELECT * FROM table LIMIT 2
     #   # => [{:id=>6}, {:id=>4}]
     #
-    #   DB[:table].first(:id=>2) # SELECT * FROM table WHERE (id = 2) LIMIT 1
+    #   DB[:table].first(id: 2) # SELECT * FROM table WHERE (id = 2) LIMIT 1
     #   # => {:id=>2}
     #
-    #   DB[:table].first("id = 3") # SELECT * FROM table WHERE (id = 3) LIMIT 1
+    #   DB[:table].first(Sequel.lit("id = 3")) # SELECT * FROM table WHERE (id = 3) LIMIT 1
     #   # => {:id=>3}
     #
-    #   DB[:table].first("id = ?", 4) # SELECT * FROM table WHERE (id = 4) LIMIT 1
+    #   DB[:table].first(Sequel.lit("id = ?", 4)) # SELECT * FROM table WHERE (id = 4) LIMIT 1
     #   # => {:id=>4}
     #
     #   DB[:table].first{id > 2} # SELECT * FROM table WHERE (id > 2) LIMIT 1
     #   # => {:id=>5}
     #
-    #   DB[:table].first("id > ?", 4){id < 6} # SELECT * FROM table WHERE ((id > 4) AND (id < 6)) LIMIT 1
+    #   DB[:table].first(Sequel.lit("id > ?", 4)){id < 6} # SELECT * FROM table WHERE ((id > 4) AND (id < 6)) LIMIT 1
     #   # => {:id=>5}
     #
     #   DB[:table].first(2){id < 2} # SELECT * FROM table WHERE (id < 2) LIMIT 2
@@ -361,7 +355,8 @@ module Sequel
     end
 
     # Inserts values into the associated table.  The returned value is generally
-    # the value of the primary key for the inserted row, but that is adapter dependent.
+    # the value of the autoincremented primary key for the inserted row, assuming that
+    # the a single row is inserted and the table has an autoincrementing primary key.
     #
     # +insert+ handles a number of different argument formats:
     # no arguments or single empty hash :: Uses DEFAULT VALUES
@@ -387,7 +382,7 @@ module Sequel
     #   DB[:items].insert([:a, :b], [1,2])
     #   # INSERT INTO items (a, b) VALUES (1, 2)
     #
-    #   DB[:items].insert(:a => 1, :b => 2)
+    #   DB[:items].insert(a: 1, b: 2)
     #   # INSERT INTO items (a, b) VALUES (1, 2)
     #
     #   DB[:items].insert(DB[:old_items])
@@ -404,26 +399,6 @@ module Sequel
       end
     end
     
-    # Returns the interval between minimum and maximum values for the given 
-    # column/expression. Uses a virtual row block if no argument is given.
-    #
-    #   DB[:table].interval(:id) # SELECT (max(id) - min(id)) FROM table LIMIT 1
-    #   # => 6
-    #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
-    #   # => 7
-    def interval(column=Sequel.virtual_row(&Proc.new))
-      Sequel::Deprecation.deprecate("Sequel::Dataset#interval", "Use #max - #min, or use the sequel_4_dataset_methods extension")
-      if loader = cached_placeholder_literalizer(:_interval_loader) do |pl|
-          arg = pl.arg
-          aggregate_dataset.limit(1).select((SQL::Function.new(:max, arg) - SQL::Function.new(:min, arg)).as(:interval))
-        end
-
-        loader.get(column)
-      else
-        aggregate_dataset.get{(max(column) - min(column)).as(:interval)}
-      end
-    end
-
     # Reverses the order and then runs #first with the given arguments and block.  Note that this
     # will not necessarily give you the last record in the dataset,
     # unless you have an unambiguous order.  If there is not
@@ -439,8 +414,8 @@ module Sequel
       reverse.first(*args, &block)
     end
     
-    # Maps column values for each record in the dataset (if a column name is
-    # given), or performs the stock mapping functionality of +Enumerable+ otherwise. 
+    # Maps column values for each record in the dataset (if an argument is given)
+    # or performs the stock mapping functionality of +Enumerable+ otherwise. 
     # Raises an +Error+ if both an argument and block are given.
     #
     #   DB[:table].map(:id) # SELECT * FROM table
@@ -492,7 +467,7 @@ module Sequel
     # This is a front end for import that allows you to submit an array of
     # hashes instead of arrays of columns and values:
     # 
-    #   DB[:table].multi_insert([{:x => 1}, {:x => 2}])
+    #   DB[:table].multi_insert([{x: 1}, {x: 2}])
     #   # INSERT INTO table (x) VALUES (1)
     #   # INSERT INTO table (x) VALUES (2)
     #
@@ -519,6 +494,10 @@ module Sequel
     # Sequel checks that the datasets using this method have an order, but it cannot
     # ensure that the order is unambiguous.
     #
+    # Note that this method is not safe to use on many adapters if you are
+    # running additional queries inside the provided block.  If you are
+    # running queries inside the block, use a separate thread or shard inside +paged_each+.
+    #
     # Options:
     # :rows_per_fetch :: The number of rows to fetch per query.  Defaults to 1000.
     # :strategy :: The strategy to use for paging of results.  By default this is :offset,
@@ -528,7 +507,7 @@ module Sequel
     #              selecting the columns you are ordering by, and none of the columns can contain
     #              NULLs.  Note that some Sequel adapters have optimized implementations that will
     #              use cursors or streaming regardless of the :strategy option used.
-    # :filter_values :: If the :strategy=>:filter option is used, this option should be a proc
+    # :filter_values :: If the strategy: :filter option is used, this option should be a proc
     #                   that accepts the last retreived row for the previous page and an array of
     #                   ORDER BY expressions, and returns an array of values relating to those
     #                   expressions for the last retrieved row.  You will need to use this option
@@ -548,13 +527,13 @@ module Sequel
     #   # SELECT * FROM table ORDER BY id LIMIT 100 OFFSET 100
     #   # ...
     #
-    #   DB[:table].order(:id).paged_each(:strategy=>:filter){|row| }
+    #   DB[:table].order(:id).paged_each(strategy: :filter){|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 1000
     #   # SELECT * FROM table WHERE id > 1001 ORDER BY id LIMIT 1000
     #   # ...
     #
-    #   DB[:table].order(:table__id).paged_each(:strategy=>:filter,
-    #     :filter_values=>proc{|row, exprs| [row[:id]]}){|row| }
+    #   DB[:table].order(:id).paged_each(strategy: :filter,
+    #     filter_values: lambda{|row, exprs| [row[:id]]}){|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 1000
     #   # SELECT * FROM table WHERE id > 1001 ORDER BY id LIMIT 1000
     #   # ...
@@ -618,30 +597,6 @@ module Sequel
       self
     end
 
-    # Returns a +Range+ instance made from the minimum and maximum values for the
-    # given column/expression.  Uses a virtual row block if no argument is given.
-    #
-    #   DB[:table].range(:id) # SELECT max(id) AS v1, min(id) AS v2 FROM table LIMIT 1
-    #   # => 1..10
-    #   DB[:table].interval{function(column)} # SELECT max(function(column)) AS v1, min(function(column)) AS v2 FROM table LIMIT 1
-    #   # => 0..7
-    def range(column=Sequel.virtual_row(&Proc.new))
-      Sequel::Deprecation.deprecate("Sequel::Dataset#range", "Use #min..#max, or use the sequel_4_dataset_methods extension")
-      r = if loader = cached_placeholder_literalizer(:_range_loader) do |pl|
-            arg = pl.arg
-            aggregate_dataset.limit(1).select(SQL::Function.new(:min, arg).as(:v1), SQL::Function.new(:max, arg).as(:v2))
-          end
-
-        loader.first(column)
-      else
-        aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
-      end
-
-      if r
-        (r[:v1]..r[:v2])
-      end
-    end
-    
     # Returns a hash with key_column values as keys and value_column values as
     # values.  Similar to as_hash, but only selects the columns given.  Like
     # as_hash, it accepts an optional :hash parameter, into which entries will
@@ -657,8 +612,7 @@ module Sequel
     #   # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
     #
     # When using this method, you must be sure that each expression has an alias
-    # that Sequel can determine.  Usually you can do this by calling the #as method
-    # on the expression and providing an alias.
+    # that Sequel can determine.
     def select_hash(key_column, value_column, opts = OPTS)
       _select_hash(:as_hash, key_column, value_column, opts)
     end
@@ -677,8 +631,7 @@ module Sequel
     #   # {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
     #
     # When using this method, you must be sure that each expression has an alias
-    # that Sequel can determine.  Usually you can do this by calling the #as method
-    # on the expression and providing an alias.
+    # that Sequel can determine.
     def select_hash_groups(key_column, value_column, opts = OPTS)
       _select_hash(:to_hash_groups, key_column, value_column, opts)
     end
@@ -701,8 +654,7 @@ module Sequel
     #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     #
     # If you provide an array of expressions, you must be sure that each entry
-    # in the array has an alias that Sequel can determine.  Usually you can do this
-    # by calling the #as method on the expression and providing an alias.
+    # in the array has an alias that Sequel can determine.
     def select_map(column=nil, &block)
       _select_map(column, false, &block)
     end
@@ -721,8 +673,7 @@ module Sequel
     #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     #
     # If you provide an array of expressions, you must be sure that each entry
-    # in the array has an alias that Sequel can determine.  Usually you can do this
-    # by calling the #as method on the expression and providing an alias.
+    # in the array has an alias that Sequel can determine.
     def select_order_map(column=nil, &block)
       _select_map(column, true, &block)
     end
@@ -817,21 +768,21 @@ module Sequel
         return naked.as_hash(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
-            send(meth){|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
+            public_send(meth){|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
           else
-            send(meth){|r| h[r[key_column]] = r.values_at(*value_column)}
+            public_send(meth){|r| h[r[key_column]] = r.values_at(*value_column)}
           end
         else
           if key_column.is_a?(Array)
-            send(meth){|r| h[r.values_at(*key_column)] = r[value_column]}
+            public_send(meth){|r| h[r.values_at(*key_column)] = r[value_column]}
           else
-            send(meth){|r| h[r[key_column]] = r[value_column]}
+            public_send(meth){|r| h[r[key_column]] = r[value_column]}
           end
         end
       elsif key_column.is_a?(Array)
-        send(meth){|r| h[key_column.map{|k| r[k]}] = r}
+        public_send(meth){|r| h[key_column.map{|k| r[k]}] = r}
       else
-        send(meth){|r| h[r[key_column]] = r}
+        public_send(meth){|r| h[r[key_column]] = r}
       end
       h
     end
@@ -872,21 +823,21 @@ module Sequel
         return naked.to_hash_groups(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
-            send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r.values_at(*value_column)}
+            public_send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r.values_at(*value_column)}
           else
-            send(meth){|r| (h[r[key_column]] ||= []) << r.values_at(*value_column)}
+            public_send(meth){|r| (h[r[key_column]] ||= []) << r.values_at(*value_column)}
           end
         else
           if key_column.is_a?(Array)
-            send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r[value_column]}
+            public_send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r[value_column]}
           else
-            send(meth){|r| (h[r[key_column]] ||= []) << r[value_column]}
+            public_send(meth){|r| (h[r[key_column]] ||= []) << r[value_column]}
           end
         end
       elsif key_column.is_a?(Array)
-        send(meth){|r| (h[key_column.map{|k| r[k]}] ||= []) << r}
+        public_send(meth){|r| (h[key_column.map{|k| r[k]}] ||= []) << r}
       else
-        send(meth){|r| (h[r[key_column]] ||= []) << r}
+        public_send(meth){|r| (h[r[key_column]] ||= []) << r}
       end
       h
     end
@@ -899,15 +850,14 @@ module Sequel
       execute_ddl(truncate_sql)
     end
 
-    # Updates values for the dataset.  The returned value is generally the
-    # number of rows updated, but that is adapter dependent. +values+ should
-    # a hash where the keys are columns to set and values are the values to
+    # Updates values for the dataset.  The returned value is the number of rows updated.
+    # +values+ should be a hash where the keys are columns to set and values are the values to
     # which to set the columns.
     #
-    #   DB[:table].update(:x=>nil) # UPDATE table SET x = NULL
+    #   DB[:table].update(x: nil) # UPDATE table SET x = NULL
     #   # => 10
     #
-    #   DB[:table].update(:x=>Sequel[:x]+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
+    #   DB[:table].update(x: Sequel[:x]+1, y: 0) # UPDATE table SET x = (x + 1), y = 0
     #   # => 10
     def update(values=OPTS, &block)
       sql = update_sql(values)
@@ -922,7 +872,7 @@ module Sequel
     # yielding each row to the given block.  Basically the same as where(cond).all(&block),
     # except it can be optimized to not create an intermediate dataset.
     #
-    #   DB[:table].where_all(:id=>[1,2,3])
+    #   DB[:table].where_all(id: [1,2,3])
     #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
     def where_all(cond, &block)
       if loader = _where_loader
@@ -936,7 +886,7 @@ module Sequel
     # yielding each row to the given block.  Basically the same as where(cond).each(&block),
     # except it can be optimized to not create an intermediate dataset.
     #
-    #   DB[:table].where_each(:id=>[1,2,3]){|row| p row}
+    #   DB[:table].where_each(id: [1,2,3]){|row| p row}
     #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
     def where_each(cond, &block)
       if loader = _where_loader
@@ -951,7 +901,7 @@ module Sequel
     # a single column.  Basically the same as where(cond).single_value,
     # except it can be optimized to not create an intermediate dataset.
     #
-    #   DB[:table].select(:name).where_single_value(:id=>1)
+    #   DB[:table].select(:name).where_single_value(id: 1)
     #   # SELECT name FROM table WHERE (id = 1) LIMIT 1
     def where_single_value(cond)
       if loader = cached_placeholder_literalizer(:_where_single_value_loader) do |pl|
@@ -1069,7 +1019,7 @@ module Sequel
     # Internals of +select_hash+ and +select_hash_groups+
     def _select_hash(meth, key_column, value_column, opts=OPTS)
       select(*(key_column.is_a?(Array) ? key_column : [key_column]) + (value_column.is_a?(Array) ? value_column : [value_column])).
-        send(meth, hash_key_symbols(key_column), hash_key_symbols(value_column), opts)
+        public_send(meth, hash_key_symbols(key_column), hash_key_symbols(value_column), opts)
     end
     
     # Internals of +select_map+ and +select_order_map+

data/lib/sequel/dataset/dataset_module.rb

@@ -17,22 +17,10 @@ module Sequel
     #   DB[:table].active.with_id_and_name.by_id
     #   # SELECT id, name FROM table WHERE active ORDER BY id
     class DatasetModule < ::Module
-      %w'where exclude exclude_having having'.map(&:to_sym).each do |meth|
-        define_method(meth) do |name, *args, &block|
-          if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
-            define_method(name){send(meth, *args, &block)}
-          else
-            key = :"_#{meth}_#{name}_ds"
-            define_method(name) do
-              cached_dataset(key){send(meth, *args)}
-            end
-          end
-        end
-      end
-
       meths = (<<-METHS).split.map(&:to_sym)
+        where exclude exclude_having having
         distinct grep group group_and_count group_append 
-        limit offset order order_append order_prepend 
+        limit offset order order_append order_prepend reverse 
         select select_all select_append select_group server
       METHS
 
@@ -40,11 +28,11 @@ module Sequel
       def self.def_dataset_caching_method(mod, meth)
         mod.send(:define_method, meth) do |name, *args, &block|
           if block
-            define_method(name){send(meth, *args, &block)}
+            define_method(name){public_send(meth, *args, &block)}
           else
             key = :"_#{meth}_#{name}_ds"
             define_method(name) do
-              cached_dataset(key){send(meth, *args)}
+              cached_dataset(key){public_send(meth, *args)}
             end
           end
         end

data/lib/sequel/dataset/features.rb

@@ -14,39 +14,38 @@ module Sequel
     end
     
     # Whether this dataset will provide accurate number of rows matched for
-    # delete and update statements.  Accurate in this case is the number of
+    # delete and update statements, true by default.  Accurate in this case is the number of
     # rows matched by the dataset's filter.
     def provides_accurate_rows_matched?
       true
     end
     
-    # Whether you must use a column alias list for recursive CTEs (false by
-    # default).
+    # Whether you must use a column alias list for recursive CTEs, false by default.
     def recursive_cte_requires_column_aliases?
       false
     end
 
-    # Whether the dataset requires SQL standard datetimes (false by default,
-    # as most allow strings with ISO 8601 format).
+    # Whether the dataset requires SQL standard datetimes. False by default,
+    # as most allow strings with ISO 8601 format.
     def requires_sql_standard_datetimes?
       false
     end
 
     # Whether type specifiers are required for prepared statement/bound
-    # variable argument placeholders (i.e. :bv__integer)
+    # variable argument placeholders (i.e. :bv__integer), false by default.
     def requires_placeholder_type_specifiers?
       false
     end
 
-    # Whether the dataset supports common table expressions (the WITH clause).
+    # Whether the dataset supports common table expressions, false by default.
     # If given, +type+ can be :select, :insert, :update, or :delete, in which case it
     # determines whether WITH is supported for the respective statement type.
     def supports_cte?(type=:select)
       false
     end
 
-    # Whether the dataset supports common table expressions (the WITH clause)
-    # in subqueries.  If false, applies the WITH clause to the main query, which can cause issues
+    # Whether the dataset supports common table expressions in subqueries, false by default.
+    # If false, applies the WITH clause to the main query, which can cause issues
     # if multiple WITH clauses use the same name.
     def supports_cte_in_subqueries?
       false
@@ -64,23 +63,23 @@ module Sequel
       false
     end
 
-    # Whether the dataset supports CUBE with GROUP BY.
+    # Whether the dataset supports CUBE with GROUP BY, false by default.
     def supports_group_cube?
       false
     end
 
-    # Whether the dataset supports ROLLUP with GROUP BY.
+    # Whether the dataset supports ROLLUP with GROUP BY, false by default.
     def supports_group_rollup?
       false
     end
 
-    # Whether the dataset supports GROUPING SETS with GROUP BY.
+    # Whether the dataset supports GROUPING SETS with GROUP BY, false by default.
     def supports_grouping_sets?
       false
     end
 
     # Whether this dataset supports the +insert_select+ method for returning all columns values
-    # directly from an insert query.
+    # directly from an insert query, false by default.
     def supports_insert_select?
       supports_returning?(:insert)
     end
@@ -95,33 +94,34 @@ module Sequel
       true
     end
 
-    # Whether the dataset supports the IS TRUE syntax.
+    # Whether the dataset supports the IS TRUE syntax, true by default.
     def supports_is_true?
       true
     end
     
-    # Whether the dataset supports the JOIN table USING (column1, ...) syntax.
+    # Whether the dataset supports the JOIN table USING (column1, ...) syntax, true by default.
+    # If false, support is emulated using JOIN table ON (table.column1 = other_table.column1).
     def supports_join_using?
       true
     end
     
-    # Whether the dataset supports LATERAL for subqueries in the FROM or JOIN clauses.
+    # Whether the dataset supports LATERAL for subqueries in the FROM or JOIN clauses, false by default.
     def supports_lateral_subqueries?
       false
     end
 
-    # Whether limits are supported in correlated subqueries.  True by default.
+    # Whether limits are supported in correlated subqueries, true by default.
     def supports_limits_in_correlated_subqueries?
       true
     end
     
-    # Whether modifying joined datasets is supported.
+    # Whether modifying joined datasets is supported, false by default.
     def supports_modifying_joins?
       false
     end
     
     # Whether the IN/NOT IN operators support multiple columns when an
-    # array of values is given.
+    # array of values is given, true by default.
     def supports_multiple_column_in?
       true
     end
@@ -132,12 +132,12 @@ module Sequel
     end
 
     # Whether the dataset supports or can fully emulate the DISTINCT ON clause,
-    # including respecting the ORDER BY clause, false by default
+    # including respecting the ORDER BY clause, false by default.
     def supports_ordered_distinct_on?
       supports_distinct_on?
     end
     
-    # Whether the dataset supports pattern matching by regular expressions.
+    # Whether the dataset supports pattern matching by regular expressions, false by default.
     def supports_regexp?
       false
     end
@@ -147,39 +147,39 @@ module Sequel
       false
     end
 
-    # Whether the RETURNING clause is supported for the given type of query.
+    # Whether the RETURNING clause is supported for the given type of query, false by default.
     # +type+ can be :insert, :update, or :delete.
     def supports_returning?(type)
       false
     end
 
-    # Whether the dataset supports skipping locked rows when returning data.
+    # Whether the dataset supports skipping locked rows when returning data, false by default.
     def supports_skip_locked?
       false
     end
 
-    # Whether the database supports SELECT *, column FROM table
+    # Whether the database supports <tt>SELECT *, column FROM table</tt>, true by default.
     def supports_select_all_and_column?
       true
     end
 
-    # Whether the dataset supports timezones in literal timestamps
+    # Whether the dataset supports timezones in literal timestamps, false by default.
     def supports_timestamp_timezones?
       false
     end
     
-    # Whether the dataset supports fractional seconds in literal timestamps
+    # Whether the dataset supports fractional seconds in literal timestamps, true by default.
     def supports_timestamp_usecs?
       true
     end
     
-    # Whether the dataset supports window functions.
+    # Whether the dataset supports window functions, false by default.
     def supports_window_functions?
       false
     end
     
     # Whether the dataset supports WHERE TRUE (or WHERE 1 for databases that
-    # that use 1 for true).
+    # that use 1 for true), true by default.
     def supports_where_true?
       true
     end
@@ -187,12 +187,17 @@ module Sequel
     private
 
     # Whether insert(nil) or insert({}) must be emulated by
-    # using at least one value, false by default.
+    # using at least one value.
     def insert_supports_empty_values?
       true
     end
 
-    # Whether the database supports quoting function names, false by default.
+    # Whether common table expressions are supported in UNION/INTERSECT/EXCEPT clauses.
+    def supports_cte_in_compounds?
+      supports_cte_in_subqueries?
+    end
+
+    # Whether the database supports quoting function names.
     def supports_quoted_function_names?
       false
     end