sequel 3.21.0 → 3.28.0

data/lib/sequel/database/schema_methods.rb

@@ -1,7 +1,7 @@
 module Sequel
   class Database
     # ---------------------
-    # :section: Methods that modify the database schema
+    # :section: 2 - Methods that modify the database schema
     # These methods execute code on the database that modifies the database's schema.
     # ---------------------
 
@@ -21,7 +21,7 @@ module Sequel
     UNSIGNED = ' UNSIGNED'.freeze
 
     # The order of column modifiers to use when defining a column.
-    COLUMN_DEFINITION_ORDER = [:default, :null, :unique, :primary_key, :auto_increment, :references]
+    COLUMN_DEFINITION_ORDER = [:collate, :default, :null, :unique, :primary_key, :auto_increment, :references]
 
     # Adds a column to the specified table. This method expects a column name,
     # a datatype and optionally a hash with additional constraints and options:
@@ -29,7 +29,7 @@ module Sequel
     #   DB.add_column :items, :name, :text, :unique => true, :null => false
     #   DB.add_column :items, :category, :text, :default => 'ruby'
     #
-    # See alter_table.
+    # See <tt>alter_table</tt>.
     def add_column(table, *args)
       alter_table(table) {add_column(*args)}
     end
@@ -40,9 +40,9 @@ module Sequel
     #   DB.add_index :posts, [:author, :title], :unique => true
     #
     # Options:
-    # * :ignore_errors - Ignore any DatabaseErrors that are raised
+    # :ignore_errors :: Ignore any DatabaseErrors that are raised
     #
-    # See alter_table.
+    # See <tt>alter_table</tt>.
     def add_index(table, columns, options={})
       e = options[:ignore_errors]
       begin
@@ -65,10 +65,10 @@ module Sequel
     #   end
     #
     # Note that +add_column+ accepts all the options available for column
-    # definitions using create_table, and +add_index+ accepts all the options
+    # definitions using <tt>create_table</tt>, and +add_index+ accepts all the options
     # available for index definition.
     #
-    # See Schema::AlterTableGenerator and the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
+    # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
     def alter_table(name, generator=nil, &block)
       generator ||= Schema::AlterTableGenerator.new(self, &block)
       alter_table_sql_list(name, generator.operations).flatten.each {|sql| execute_ddl(sql)}
@@ -89,7 +89,7 @@ module Sequel
     # :temp :: Create the table as a temporary table.
     # :ignore_index_errors :: Ignore any errors when creating indexes.
     #
-    # See Schema::Generator and the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
+    # See <tt>Schema::Generator</tt> and the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
     def create_table(name, options={}, &block)
       remove_cached_schema(name)
       options = {:generator=>options} if options.is_a?(Schema::Generator)
@@ -99,19 +99,28 @@ module Sequel
       nil
     end
     
-    # Forcibly creates a table, attempting to drop it unconditionally (and catching any errors), then creating it.
+    # Forcibly create a table, attempting to drop it if it already exists, then creating it.
     # 
     #   DB.create_table!(:a){Integer :a} 
-    #   # DROP TABLE a
+    #   # SELECT * FROM a LIMIT a -- check existence
+    #   # DROP TABLE a -- drop table if already exists
     #   # CREATE TABLE a (a integer)
     def create_table!(name, options={}, &block)
-      drop_table(name) rescue nil
+      drop_table(name) if table_exists?(name)
       create_table(name, options, &block)
     end
     
-    # Creates the table unless the table already exists
+    # Creates the table unless the table already exists.
+    # 
+    #   DB.create_table?(:a){Integer :a} 
+    #   # SELECT * FROM a LIMIT a -- check existence
+    #   # CREATE TABLE a (a integer) -- if it doesn't already exist
     def create_table?(name, options={}, &block)
-      create_table(name, options, &block) unless table_exists?(name)
+      if supports_create_table_if_not_exists?
+        create_table(name, options.merge(:if_not_exists=>true), &block)
+      elsif !table_exists?(name)
+        create_table(name, options, &block)
+      end
     end
     
     # Creates a view, replacing it if it already exists:
@@ -138,7 +147,7 @@ module Sequel
     #
     #   DB.drop_column :items, :category
     #
-    # See alter_table.
+    # See <tt>alter_table</tt>.
     def drop_column(table, *args)
       alter_table(table) {drop_column(*args)}
     end
@@ -148,17 +157,20 @@ module Sequel
     #   DB.drop_index :posts, :title
     #   DB.drop_index :posts, [:author, :title]
     #
-    # See alter_table.
+    # See <tt>alter_table</tt>.
     def drop_index(table, columns, options={})
       alter_table(table){drop_index(columns, options)}
     end
     
     # Drops one or more tables corresponding to the given names:
     #
+    #   DB.drop_table(:posts)
     #   DB.drop_table(:posts, :comments)
+    #   DB.drop_table(:posts, :comments, :cascade=>true)
     def drop_table(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
       names.each do |n|
-        execute_ddl(drop_table_sql(n))
+        execute_ddl(drop_table_sql(n, options))
         remove_cached_schema(n)
       end
       nil
@@ -167,9 +179,12 @@ module Sequel
     # Drops one or more views corresponding to the given names:
     #
     #   DB.drop_view(:cheap_items)
+    #   DB.drop_view(:cheap_items, :pricey_items)
+    #   DB.drop_view(:cheap_items, :pricey_items, :cascade=>true)
     def drop_view(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
       names.each do |n|
-        execute_ddl("DROP VIEW #{quote_schema_table(n)}")
+        execute_ddl(drop_view_sql(n, options))
         remove_cached_schema(n)
       end
       nil
@@ -191,7 +206,7 @@ module Sequel
     #
     #   DB.rename_column :items, :cntr, :counter
     #
-    # See alter_table.
+    # See <tt>alter_table</tt>.
     def rename_column(table, *args)
       alter_table(table) {rename_column(*args)}
     end
@@ -200,7 +215,7 @@ module Sequel
     #
     #   DB.set_column_default :items, :category, 'perl!'
     #
-    # See alter_table.
+    # See <tt>alter_table</tt>.
     def set_column_default(table, *args)
       alter_table(table) {set_column_default(*args)}
     end
@@ -209,7 +224,7 @@ module Sequel
     #
     #   DB.set_column_type :items, :price, :float
     #
-    # See alter_table.
+    # See <tt>alter_table</tt>.
     def set_column_type(table, *args)
       alter_table(table) {set_column_type(*args)}
     end
@@ -224,7 +239,7 @@ module Sequel
       when :add_column
         "ADD COLUMN #{column_definition_sql(op)}"
       when :drop_column
-        "DROP COLUMN #{quoted_name}"
+        "DROP COLUMN #{quoted_name}#{' CASCADE' if op[:cascade]}"
       when :rename_column
         "RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
       when :set_column_type
@@ -240,7 +255,7 @@ module Sequel
       when :add_constraint
         "ADD #{constraint_definition_sql(op)}"
       when :drop_constraint
-        "DROP CONSTRAINT #{quoted_name}"
+        "DROP CONSTRAINT #{quoted_name}#{' CASCADE' if op[:cascade]}"
       else
         raise Error, "Unsupported ALTER TABLE operation"
       end
@@ -275,7 +290,12 @@ module Sequel
     def column_definition_auto_increment_sql(sql, column)
       sql << " #{auto_increment_sql}" if column[:auto_increment]
     end
-    
+
+    # Add collate SQL fragment to column creation SQL.
+    def column_definition_collate_sql(sql, column)
+      sql << " COLLATE #{column[:collate]}" if column[:collate]
+    end
+
     # Add default SQL fragment to column creation SQL.
     def column_definition_default_sql(sql, column)
       sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
@@ -354,7 +374,7 @@ module Sequel
 
     # Execute the create index statements using the generator.
     def create_table_indexes_from_generator(name, generator, options)
-      e = options[:ignore_index_errors]
+      e = options[:ignore_index_errors] || options[:if_not_exists]
       generator.indexes.each do |index|
         begin
           index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}
@@ -366,7 +386,7 @@ module Sequel
 
     # DDL statement for creating a table with the given name, columns, and options
     def create_table_sql(name, generator, options)
-      "CREATE #{temporary_table_sql if options[:temp]}TABLE #{quote_schema_table(name)} (#{column_list_sql(generator)})"
+      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)} (#{column_list_sql(generator)})"
     end
 
     # Default index name for the table and columns, may be too long
@@ -382,10 +402,15 @@ module Sequel
     end
 
     # SQL DDL statement to drop the table with the given name.
-    def drop_table_sql(name)
-      "DROP TABLE #{quote_schema_table(name)}"
+    def drop_table_sql(name, options)
+      "DROP TABLE #{quote_schema_table(name)}#{' CASCADE' if options[:cascade]}"
     end
     
+    # SQL DDL statement to drop a view with the given name.
+    def drop_view_sql(name, options)
+      "DROP VIEW #{quote_schema_table(name)}#{' CASCADE' if options[:cascade]}"
+    end
+
     # Proxy the filter_expr call to the dataset, used for creating constraints.
     def filter_expr(*args, &block)
       schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))

data/lib/sequel/dataset/actions.rb

@@ -1,7 +1,7 @@
 module Sequel
   class Dataset
     # ---------------------
-    # :section: Methods that execute code on the database
+    # :section: 2 - Methods that execute code on the database
     # These methods all execute the dataset's SQL on the database.
     # They don't return modified datasets, so if used in a method chain
     # they should be the last method called.
@@ -101,10 +101,15 @@ module Sequel
     #
     #   DB[:table].delete # DELETE * FROM table
     #   # => 3
-    def delete
-      execute_dui(delete_sql)
+    def delete(&block)
+      sql = delete_sql
+      if uses_returning?(:delete)
+        returning_fetch_rows(sql, &block)
+      else
+        execute_dui(sql)
+      end
     end
-    
+
     # Iterates over the records in the dataset as they are yielded from the
     # database adapter, and returns self.
     #
@@ -248,14 +253,16 @@ module Sequel
     # the value of the primary key for the inserted row, but that is adapter dependent.
     #
     # +insert+ handles a number of different argument formats:
-    # * No arguments, single empty hash - Uses DEFAULT VALUES
-    # * Single hash - Most common format, treats keys as columns an values as values
-    # * Single array - Treats entries as values, with no columns
-    # * Two arrays - Treats first array as columns, second array as values
-    # * Single Dataset - Treats as an insert based on a selection from the dataset given,
-    #   with no columns
-    # * Array and dataset - Treats as an insert based on a selection from the dataset
-    #   given, with the columns given by the array.
+    # no arguments or single empty hash :: Uses DEFAULT VALUES
+    # single hash :: Most common format, treats keys as columns an values as values
+    # single array :: Treats entries as values, with no columns
+    # two arrays :: Treats first array as columns, second array as values
+    # single Dataset :: Treats as an insert based on a selection from the dataset given,
+    #                   with no columns
+    # array and dataset :: Treats as an insert based on a selection from the dataset
+    #                      given, with the columns given by the array.
+    #
+    # Examples:
     #
     #   DB[:items].insert
     #   # INSERT INTO items DEFAULT VALUES
@@ -277,8 +284,13 @@ module Sequel
     #
     #   DB[:items].insert([:a, :b], DB[:old_items])
     #   # INSERT INTO items (a, b) SELECT * FROM old_items
-    def insert(*values)
-      execute_insert(insert_sql(*values))
+    def insert(*values, &block)
+      sql = insert_sql(*values)
+      if uses_returning?(:insert)
+        returning_fetch_rows(sql, &block)
+      else
+        execute_insert(sql)
+      end
     end
     
     # Inserts multiple values. If a block is given it is invoked for each
@@ -310,7 +322,7 @@ module Sequel
       aggregate_dataset.get{max(column) - min(column)}
     end
 
-    # Reverses the order and then runs first.  Note that this
+    # 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
     # currently an order for this dataset, raises an +Error+.
@@ -334,10 +346,19 @@ module Sequel
     #
     #   DB[:table].map{|r| r[:id] * 2} # SELECT * FROM table
     #   # => [2, 4, 6, ...]
+    #
+    # You can also provide an array of column names:
+    #
+    #   DB[:table].map([:id, :name]) # SELECT * FROM table
+    #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     def map(column=nil, &block)
       if column
         raise(Error, ARG_BLOCK_ERROR_MSG) if block
-        super(){|r| r[column]}
+        if column.is_a?(Array)
+          super(){|r| column.map{|c| r[c]}}
+        else
+          super(){|r| r[column]}
+        end
       else
         super(&block)
       end
@@ -393,49 +414,63 @@ module Sequel
     #
     #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
     #   # => {1=>'a', 2=>'b', ...}
+    #
+    # You can also provide an array of column names for either the key_column,
+    # the value column, or both:
+    #
+    #   DB[:table].select_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
+    #   # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
     def select_hash(key_column, value_column)
-      select(key_column, value_column).to_hash(hash_key_symbol(key_column), hash_key_symbol(value_column))
+      if key_column.is_a?(Array)
+        if value_column.is_a?(Array)
+          select(*(key_column + value_column)).to_hash(key_column.map{|c| hash_key_symbol(c)}, value_column.map{|c| hash_key_symbol(c)})
+        else
+          select(*(key_column + [value_column])).to_hash(key_column.map{|c| hash_key_symbol(c)}, hash_key_symbol(value_column))
+        end
+      elsif value_column.is_a?(Array)
+        select(key_column, *value_column).to_hash(hash_key_symbol(key_column), value_column.map{|c| hash_key_symbol(c)})
+      else
+        select(key_column, value_column).to_hash(hash_key_symbol(key_column), hash_key_symbol(value_column))
+      end
     end
     
     # Selects the column given (either as an argument or as a block), and
     # returns an array of all values of that column in the dataset.  If you
     # give a block argument that returns an array with multiple entries,
-    # the contents of the resulting array are undefined.
+    # the contents of the resulting array are undefined.  Raises an Error
+    # if called with both an argument and a block.
     #
     #   DB[:table].select_map(:id) # SELECT id FROM table
     #   # => [3, 5, 8, 1, ...]
     #
-    #   DB[:table].select_map{abs(id)} # SELECT abs(id) FROM table
-    #   # => [3, 5, 8, 1, ...]
+    #   DB[:table].select_map{id * 2} # SELECT (id * 2) FROM table
+    #   # => [6, 10, 16, 2, ...]
+    #
+    # You can also provide an array of column names:
+    #
+    #   DB[:table].select_map([:id, :name]) # SELECT id, name FROM table
+    #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     def select_map(column=nil, &block)
-      ds = naked.ungraphed
-      ds = if column
-        raise(Error, ARG_BLOCK_ERROR_MSG) if block
-        ds.select(column)
-      else
-        ds.select(&block)
-      end
-      ds.map{|r| r.values.first}
+      _select_map(column, false, &block)
     end
+
     
     # The same as select_map, but in addition orders the array by the column.
     #
     #   DB[:table].select_order_map(:id) # SELECT id FROM table ORDER BY id
     #   # => [1, 2, 3, 4, ...]
     #
-    #   DB[:table].select_order_map{abs(id)} # SELECT abs(id) FROM table ORDER BY abs(id)
-    #   # => [1, 2, 3, 4, ...]
+    #   DB[:table].select_order_map{id * 2} # SELECT (id * 2) FROM table ORDER BY (id * 2)
+    #   # => [2, 4, 6, 8, ...]
+    #
+    # You can also provide an array of column names:
+    #
+    #   DB[:table].select_order_map([:id, :name]) # SELECT id, name FROM table ORDER BY id, name
+    #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     def select_order_map(column=nil, &block)
-      ds = naked.ungraphed
-      ds = if column
-        raise(Error, ARG_BLOCK_ERROR_MSG) if block
-        ds.select(column).order(unaliased_identifier(column))
-      else
-        ds.select(&block).order(&block)
-      end
-      ds.map{|r| r.values.first}
+      _select_map(column, true, &block)
     end
-  
+
     # Alias for update, but not aliased directly so subclasses
     # don't have to override both methods.
     def set(*args)
@@ -499,11 +534,37 @@ module Sequel
     #
     #   DB[:table].to_hash(:id) # SELECT * FROM table
     #   # {1=>{:id=>1, :name=>'Jim'}, 2=>{:id=>2, :name=>'Bob'}, ...}
+    #
+    # You can also provide an array of column names for either the key_column,
+    # the value column, or both:
+    #
+    #   DB[:table].to_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
+    #   # {[1, 3]=>['Jim', 'bo'], [2, 4]=>['Bob', 'be'], ...}
+    #
+    #   DB[:table].to_hash([:id, :name]) # SELECT * FROM table
+    #   # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob'=>{:id=>2, :name=>'Bob'}, ...}
     def to_hash(key_column, value_column = nil)
-      inject({}) do |m, r|
-        m[r[key_column]] = value_column ? r[value_column] : r
-        m
+      h = {}
+      if value_column
+        if value_column.is_a?(Array)
+          if key_column.is_a?(Array)
+            each{|r| h[key_column.map{|c| r[c]}] = value_column.map{|c| r[c]}}
+          else
+            each{|r| h[r[key_column]] = value_column.map{|c| r[c]}}
+          end
+        else
+          if key_column.is_a?(Array)
+            each{|r| h[key_column.map{|c| r[c]}] = r[value_column]}
+          else
+            each{|r| h[r[key_column]] = r[value_column]}
+          end
+        end
+      elsif key_column.is_a?(Array)
+        each{|r| h[key_column.map{|c| r[c]}] = r}
+      else
+        each{|r| h[r[key_column]] = r}
       end
+      h
     end
 
     # Truncates the dataset.  Returns nil.
@@ -522,14 +583,40 @@ module Sequel
     #   DB[:table].update(:x=>nil) # UPDATE table SET x = NULL
     #   # => 10
     #
-    #   DB[:table].update(:x=>:x+1, :y=>0) # UPDATE table SET x = (x + 1), :y = 0
+    #   DB[:table].update(:x=>:x+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
     #   # => 10
-    def update(values={})
-      execute_dui(update_sql(values))
+    def update(values={}, &block)
+      sql = update_sql(values)
+      if uses_returning?(:update)
+        returning_fetch_rows(sql, &block)
+      else
+        execute_dui(sql)
+      end
     end
 
     private
     
+    # Internals of +select_map+ and +select_order_map+
+    def _select_map(column, order, &block)
+      ds = naked.ungraphed
+      if column
+        raise(Error, ARG_BLOCK_ERROR_MSG) if block
+        columns = Array(column)
+        select_cols = order ? columns.map{|c| c.is_a?(SQL::OrderedExpression) ? c.expression : c} : columns
+        ds = ds.select(*select_cols)
+        ds = ds.order(*columns.map{|c| unaliased_identifier(c)}) if order
+      else
+        ds = ds.select(&block)
+        ds = ds.order(&block) if order
+      end
+      if ds.opts[:select].length > 1
+        ret_cols = select_cols.map{|c| hash_key_symbol(c)}
+        ds.map{|r| ret_cols.map{|c| r[c]}}
+      else
+        ds.map{|r| r.values.first}
+      end
+    end
+  
     # Set the server to use to :default unless it is already set in the passed opts
     def default_server_opts(opts)
       {:server=>@opts[:server] || :default}.merge(opts)
@@ -561,9 +648,19 @@ module Sequel
     # specifying the symbol that is likely to be used as the hash key
     # for the column when records are returned.
     def hash_key_symbol(s)
-      raise(Error, "#{s.inspect} is not a symbol") unless s.is_a?(Symbol)
-      _, c, a = split_symbol(s)
-      (a || c).to_sym
+      case s
+      when Symbol
+        _, c, a = split_symbol(s)
+        (a || c).to_sym
+      when SQL::Identifier
+        hash_key_symbol(s.value)
+      when SQL::QualifiedIdentifier
+        hash_key_symbol(s.column)
+      when SQL::AliasedExpression
+        hash_key_symbol(s.aliaz)
+      else
+        raise(Error, "#{s.inspect} is not supported, should be a Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression") 
+      end
     end
     
     # Modify the identifier returned from the database based on the
@@ -580,6 +677,20 @@ module Sequel
     def post_load(all_records)
     end
 
+    # Called by insert/update/delete when returning is used.
+    # Yields each row as a plain hash to the block if one is given, or returns
+    # an array of plain hashes for all rows if a block is not given
+    def returning_fetch_rows(sql, &block)
+      if block
+        default_server.fetch_rows(sql, &block)
+        nil
+      else
+        rows = []
+        default_server.fetch_rows(sql){|r| rows << r}
+        rows
+      end
+    end
+    
     # Return the unaliased part of the identifier.  Handles both
     # implicit aliases in symbols, as well as SQL::AliasedExpression
     # objects.  Other objects are returned as is.
@@ -590,6 +701,14 @@ module Sequel
         c_table ? SQL::QualifiedIdentifier.new(c_table, column.to_sym) : column.to_sym
       when SQL::AliasedExpression
         c.expression
+      when SQL::OrderedExpression
+        expr = c.expression
+        if expr.is_a?(Symbol)
+          expr = unaliased_identifier(expr)
+          SQL::OrderedExpression.new(unaliased_identifier(c.expression), c.descending, :nulls=>c.nulls)
+        else
+          c
+        end
       else
         c
       end

data/lib/sequel/dataset/features.rb

@@ -1,17 +1,20 @@
 module Sequel
   class Dataset
     # ---------------------
-    # :section: Methods that describe what the dataset supports
+    # :section: 4 - Methods that describe what the dataset supports
     # These methods all return booleans, with most describing whether or not the
     # dataset supports a feature.
     # ---------------------
     
-    # Method used to check if WITH is supported
-    WITH_SUPPORTED=:select_with_sql
-    
     # Whether this dataset quotes identifiers.
     def quote_identifiers?
-      @quote_identifiers
+      if defined?(@quote_identifiers)
+        @quote_identifiers
+      elsif db.respond_to?(:quote_identifiers?)
+        @quote_identifiers = db.quote_identifiers?
+      else
+        @quote_identifiers = false
+      end
     end
     
     # Whether this dataset will provide accurate number of rows matched for
@@ -28,15 +31,30 @@ module Sequel
     end
 
     # Whether the dataset supports common table expressions (the WITH clause).
-    def supports_cte?
-      select_clause_methods.include?(WITH_SUPPORTED)
+    # 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)
+      send(:"#{type}_clause_methods").include?(:"#{type}_with_sql")
     end
 
-    # Whether the dataset supports the DISTINCT ON clause, false by default.
+    # 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
+    # if multiple WITH clauses use the same name.
+    def supports_cte_in_subqueries?
+      false
+    end
+
+    # Whether the dataset supports or can emulate the DISTINCT ON clause, false by default.
     def supports_distinct_on?
       false
     end
 
+    # Whether this dataset supports the +insert_select+ method for returning all columns values
+    # directly from an insert query.
+    def supports_insert_select?
+      supports_returning?(:insert)
+    end
+
     # Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
     def supports_intersect_except?
       true
@@ -67,7 +85,24 @@ module Sequel
     def supports_multiple_column_in?
       true
     end
+
+    # Whether the dataset supports or can fully emulate the DISTINCT ON clause,
+    # including respecting the ORDER BY clause, false by default
+    def supports_ordered_distinct_on?
+      supports_distinct_on?
+    end
     
+    # Whether the RETURNING clause is supported for the given type of query.
+    # +type+ can be :insert, :update, or :delete.
+    def supports_returning?(type)
+      send(:"#{type}_clause_methods").include?(:"#{type}_returning_sql")
+    end
+
+    # Whether the database supports SELECT *, column FROM table
+    def supports_select_all_and_column?
+      true
+    end
+
     # Whether the dataset supports timezones in literal timestamps
     def supports_timestamp_timezones?
       false
@@ -82,5 +117,19 @@ module Sequel
     def supports_window_functions?
       false
     end
+    
+    # Whether the dataset supports WHERE TRUE (or WHERE 1 for databases that
+    # that use 1 for true).
+    def supports_where_true?
+      true
+    end
+
+    private
+
+    # Whether the RETURNING clause is used for the given dataset.
+    # +type+ can be :insert, :update, or :delete.
+    def uses_returning?(type)
+      opts[:returning] && !@opts[:sql] && supports_returning?(type)
+    end
   end
 end

data/lib/sequel/dataset/graph.rb

@@ -1,7 +1,7 @@
 module Sequel
   class Dataset
     # ---------------------
-    # :section: Methods related to dataset graphing
+    # :section: 5 - Methods related to dataset graphing
     # Dataset graphing changes the dataset to yield hashes where keys are table
     # name symbols and values are hashes representing the columns related to
     # that table.  All of these methods return modified copies of the receiver.