sequel 3.33.0 → 3.34.0

data/lib/sequel/adapters/sqlite.rb

@@ -229,13 +229,19 @@ module Sequel
           end
         end
         unless cps
-          cps = log_yield("Preparing #{name}: #{sql}"){conn.prepare(sql)}
+          cps = log_yield("PREPARE #{name}: #{sql}"){conn.prepare(sql)}
           conn.prepared_statements[name] = [cps, sql]
         end
+        log_sql = "EXECUTE #{name}"
+        if ps.log_sql
+          log_sql << " ("
+          log_sql << sql
+          log_sql << ")"
+        end
         if block
-          log_yield("Executing prepared statement #{name}", args){cps.execute(ps_args, &block)}
+          log_yield(log_sql, args){cps.execute(ps_args, &block)}
         else
-          log_yield("Executing prepared statement #{name}", args){cps.execute!(ps_args){|r|}}
+          log_yield(log_sql, args){cps.execute!(ps_args){|r|}}
           case type
           when :insert
             conn.last_insert_row_id

data/lib/sequel/adapters/swift.rb

@@ -136,10 +136,10 @@ module Sequel
       Database::DatasetClass = self
 
       # Set the columns and yield the hashes to the block.
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |res|
           @columns = res.fields
-          res.each(&block)
+          res.each{|h| yield h}
         end
         self
       end

data/lib/sequel/adapters/swift/mysql.rb

@@ -36,11 +36,6 @@ module Sequel
         include Sequel::MySQL::DatasetMethods
         APOS = Dataset::APOS
         
-        # Use execute_insert to execute the replace_sql.
-        def replace(*args)
-          execute_insert(replace_sql(*args))
-        end
-        
         private
         
         # Use Swift's escape method for quoting.

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

@@ -85,6 +85,16 @@ module Sequel
         def log_connection_execute(conn, sql)
           conn.execute(sql)
         end
+
+        # Remove all other options except for ones specifically handled, as
+        # otherwise swift passes them to dbic++ which passes them to PostgreSQL
+        # which can raise an error.
+        def server_opts(o)
+          o = super
+          so = {}
+          [:db, :user, :password, :host, :port].each{|s| so[s] = o[s] if o.has_key?(s)}
+          so
+        end
       
         # Extend the adapter with the Swift PostgreSQL AdapterMethods.
         def setup_connection(conn)

data/lib/sequel/ast_transformer.rb

@@ -66,6 +66,8 @@ module Sequel
         SQL::JoinUsingClause.new(v(o.using), o.join_type, v(o.table), v(o.table_alias))
       when SQL::JoinClause
         SQL::JoinClause.new(o.join_type, v(o.table), v(o.table_alias))
+      when SQL::Wrapper
+        SQL::Wrapper.new(v(o.value))
       else
         o
       end
@@ -172,6 +174,8 @@ module Sequel
     def v(o)
       if o.is_a?(SQL::ComplexExpression) && UNBIND_OPS.include?(o.op)
         l, r = o.args
+        l = l.value if l.is_a?(Sequel::SQL::Wrapper)
+        r = r.value if r.is_a?(Sequel::SQL::Wrapper)
         if UNBIND_KEY_CLASSES.any?{|c| l.is_a?(c)} && UNBIND_VALUE_CLASSES.any?{|c| r.is_a?(c)} && !r.is_a?(LiteralString)
           key = bind_key(l)
           if (old = binds[key]) && old != r

data/lib/sequel/connection_pool.rb

@@ -57,6 +57,14 @@ class Sequel::ConnectionPool
     end
   end
   extend ClassMethods
+
+  # The after_connect proc used for this pool.  This is called with each new
+  # connection made, and is usually used to set custom per-connection settings.
+  attr_accessor :after_connect
+
+  # The disconnect_proc used for the pool.  This is called with each connection
+  # that is disconnected, usually to clean up related resources.
+  attr_accessor :disconnection_proc
   
   # Instantiates a connection pool with the given options.  The block is called
   # with a single symbol (specifying the server/shard to use) every time a new

data/lib/sequel/connection_pool/sharded_single.rb

@@ -26,6 +26,11 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   def add_servers(servers)
     servers.each{|s| @servers[s] = s}
   end
+
+  # Yield all of the currently established connections
+  def all_connections
+    @conns.values.each{|c| yield c}
+  end
   
   # The connection for the given server.
   def conn(server=:default)

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -45,6 +45,23 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     @allocated[server]
   end
   
+  # Yield all of the available connections, and the ones currently allocated to
+  # this thread.  This will not yield connections currently allocated to other
+  # threads, as it is not safe to operate on them.  This holds the mutex while
+  # it is yielding all of the connections, which means that until
+  # the method's block returns, the pool is locked.
+  def all_connections
+    t = Thread.current
+    sync do
+      @allocated.values.each do |threads|
+        threads.each do |thread, conn|
+          yield conn if t == thread
+        end
+      end
+      @available_connections.values.each{|v| v.each{|c| yield c}}
+    end
+  end
+  
   # An array of connections opened but not currently used, for the given
   # server. Nonexistent servers will return nil. Treat this as read only, do
   # not modify the resulting object.

data/lib/sequel/connection_pool/single.rb

@@ -8,6 +8,11 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
     @conn ? 1 : 0
   end
   
+  # Yield the connection if one has been made.
+  def all_connections
+    yield @conn if @conn
+  end
+  
   # Disconnect the connection from the database.
   def disconnect(opts=nil, &block)
     return unless @conn

data/lib/sequel/connection_pool/threaded.rb

@@ -36,6 +36,20 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @allocated.length + @available_connections.length
   end
   
+  # Yield all of the available connections, and the one currently allocated to
+  # this thread.  This will not yield connections currently allocated to other
+  # threads, as it is not safe to operate on them.  This holds the mutex while
+  # it is yielding all of the available connections, which means that until
+  # the method's block returns, the pool is locked.
+  def all_connections
+    hold do |c|
+      sync do
+        yield c
+        @available_connections.each{|c| yield c}
+      end
+    end
+  end
+  
   # Removes all connections currently available, optionally
   # yielding each connection to the given block. This method has the effect of 
   # disconnecting from the database, assuming that no connections are currently

data/lib/sequel/core.rb

@@ -1,3 +1,4 @@
+warn 'Sequel support for ruby <1.8.7 is deprecated and will be removed in 3.35.0' if RUBY_VERSION < '1.8.7'
 %w'bigdecimal date thread time uri'.each{|f| require f}
 
 # Top level module for Sequel
@@ -17,8 +18,10 @@
 #
 #   Sequel.sqlite('blog.db'){|db| puts db[:users].count} 
 #
-# You can set the +SEQUEL_NO_CORE_EXTENSIONS+ constant or environment variable to have
-# Sequel not extend the core classes.
+# Sequel currently adds methods to the Array, Hash, String and Symbol classes by
+# default.  You can either require 'sequel/no_core_ext' or set the
+# +SEQUEL_NO_CORE_EXTENSIONS+ constant or environment variable before requiring
+# sequel to have # Sequel not add methods to those classes.
 #
 # For a more expanded introduction, see the {README}[link:files/README_rdoc.html].
 # For a quicker introduction, see the {cheat sheet}[link:files/doc/cheat_sheet_rdoc.html].
@@ -140,6 +143,24 @@ module Sequel
   def self.connect(*args, &block)
     Database.connect(*args, &block)
   end
+
+  if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
+    # Whether the core extensions are enabled.  The core extensions are enabled by
+    # default for backwards compatibility, but can be disabled using the SEQUEL_NO_CORE_EXTENSIONS
+    # constant or environment variable.
+    def self.core_extensions?
+      # We override this method to return true inside the core_extensions.rb file,
+      # but we also set it here because that file is not loaded until most of Sequel
+      # is finished loading, and parts of Sequel check whether the core extensions
+      # are loaded.
+      true
+    end
+  else
+    def self.core_extensions?
+      false
+    end
+  end
+
   
   # Convert the +exception+ to the given class.  The given class should be
   # <tt>Sequel::Error</tt> or a subclass.  Returns an instance of +klass+ with
@@ -356,7 +377,7 @@ module Sequel
   private_class_method :adapter_method, :def_adapter_method
   
   require(%w"metaprogramming sql connection_pool exceptions dataset database timezones ast_transformer version")
-  require('core_sql') if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
+  extension(:core_extensions) if Sequel.core_extensions?
 
   # Add the database adapter class methods to Sequel via metaprogramming
   def_adapter_method(*Database::ADAPTERS)

data/lib/sequel/database/connecting.rb

@@ -46,6 +46,7 @@ module Sequel
       when String
         if match = /\A(jdbc|do):/o.match(conn_string)
           c = adapter_class(match[1].to_sym)
+          opts = opts.merge(:orig_opts=>opts.dup)
           opts = {:uri=>conn_string}.merge(opts)
         else
           uri = URI.parse(conn_string)
@@ -55,11 +56,14 @@ module Sequel
           uri_options = c.send(:uri_to_options, uri)
           uri.query.split('&').collect{|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.unescape(v) if v.is_a?(String)}
+          opts = opts.merge(:orig_opts=>opts.dup)
+          opts[:uri] = conn_string
           opts = uri_options.merge(opts)
           opts[:adapter] = scheme
         end
       when Hash
         opts = conn_string.merge(opts)
+        opts = opts.merge(:orig_opts=>opts.dup)
         c = adapter_class(opts[:adapter_class] || opts[:adapter] || opts['adapter'])
       else
         raise Error, "Sequel::Database.connect takes either a Hash or a String, given: #{conn_string.inspect}"
@@ -209,20 +213,26 @@ module Sequel
       @single_threaded
     end
     
-    # Acquires a database connection, yielding it to the passed block. This is
-    # useful if you want to make sure the same connection is used for all
-    # database queries in the block.  It is also useful if you want to gain
-    # direct access to the underlying connection object if you need to do
-    # something Sequel does not natively support.
-    #
-    # If a server option is given, acquires a connection for that specific
-    # server, instead of the :default server.
-    #
-    #   DB.synchronize do |conn|
-    #     ...
-    #   end
-    def synchronize(server=nil, &block)
-      @pool.hold(server || :default, &block)
+    if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+      # Acquires a database connection, yielding it to the passed block. This is
+      # useful if you want to make sure the same connection is used for all
+      # database queries in the block.  It is also useful if you want to gain
+      # direct access to the underlying connection object if you need to do
+      # something Sequel does not natively support.
+      #
+      # If a server option is given, acquires a connection for that specific
+      # server, instead of the :default server.
+      #
+      #   DB.synchronize do |conn|
+      #     ...
+      #   end
+      def synchronize(server=nil)
+        @pool.hold(server || :default){|conn| yield conn}
+      end
+    else
+      def synchronize(server=nil, &block)
+        @pool.hold(server || :default, &block)
+      end
     end
     
     # Attempts to acquire a database connection.  Returns true if successful.

data/lib/sequel/database/dataset_defaults.rb

@@ -88,6 +88,7 @@ module Sequel
     #   end
     def extend_datasets(mod=nil, &block)
       raise(Error, "must provide either mod or block, not both") if mod && block
+      reset_schema_utility_dataset
       mod = Module.new(&block) if block
       if @dataset_modules.empty?
        @dataset_modules = [mod]

data/lib/sequel/database/misc.rb

@@ -121,10 +121,14 @@ module Sequel
     end
 
     # Returns a string representation of the database object including the
-    # class name and the connection URI (or the opts if the URI
-    # cannot be constructed).
+    # class name and connection URI and options used when connecting (if any).
     def inspect
-      "#<#{self.class}: #{(uri rescue opts).inspect}>" 
+      a = []
+      a << uri.inspect if uri
+      if (oo = opts[:orig_opts]) && !oo.empty?
+        a << oo.inspect
+      end
+      "#<#{self.class}: #{a.join(' ')}>"
     end
 
     # Proxy the literal call to the dataset.
@@ -148,6 +152,12 @@ module Sequel
       false
     end
 
+    # Whether the database supports DROP TABLE IF EXISTS syntax,
+    # default is the same as #supports_create_table_if_not_exists?.
+    def supports_drop_table_if_exists?
+      supports_create_table_if_not_exists?
+    end
+
     # Whether the database and adapter support prepared transactions
     # (two-phase commit), false by default.
     def supports_prepared_transactions?
@@ -197,29 +207,10 @@ module Sequel
       end
     end
     
-    # Returns the URI identifying the database, which may not be the
-    # same as the URI used when connecting.
-    # This method can raise an error if the database used options
-    # instead of a connection string, and will not include uri
-    # parameters.
-    #
-    #   Sequel.connect('postgres://localhost/db?user=billg').url
-    #   # => "postgres://billg@localhost/db"
+    # Returns the URI use to connect to the database.  If a URI
+    # was not used when connecting, returns nil.
     def uri
-      uri = URI::Generic.new(
-        adapter_scheme.to_s,
-        nil,
-        @opts[:host],
-        @opts[:port],
-        nil,
-        "/#{@opts[:database]}",
-        nil,
-        nil,
-        nil
-      )
-      uri.user = @opts[:user]
-      uri.password = @opts[:password] if uri.user
-      uri.to_s
+      opts[:uri]
     end
     
     # Explicit alias of uri for easier subclassing.

data/lib/sequel/database/query.rb

@@ -81,6 +81,24 @@ module Sequel
       execute_dui(sql, opts, &block)
     end
 
+    # Returns an array of hashes containing foreign key information from the
+    # table.  Each hash will contain at least the following fields:
+    #
+    # :columns :: An array of columns in the given table
+    # :table :: The table referenced by the columns
+    # :key :: An array of columns referenced (in the table specified by :table),
+    #         but can be nil on certain adapters if the primary key is referenced.
+    #
+    # The hash may also contain entries for:
+    #
+    # :deferrable :: Whether the constraint is deferrable
+    # :name :: The name of the constraint
+    # :on_delete :: The action to take ON DELETE
+    # :on_update :: The action to take ON UPDATE
+    def foreign_key_list(table, opts={})
+      raise NotImplemented, "#foreign_key_list should be overridden by adapters"
+    end
+    
     # Returns a single value from the database, e.g.:
     #
     #   DB.get(1) # SELECT 1
@@ -286,11 +304,11 @@ module Sequel
       if supports_savepoints?
         unless @transactions[conn]
           @transactions[conn] = {:savepoint_level=>0}
-          @transactions[conn][:prepare] = opts[:prepare] if supports_prepared_transactions?
+          @transactions[conn][:prepare] = opts[:prepare] if opts[:prepare] && supports_prepared_transactions?
         end
       else
         @transactions[conn] = {}
-        @transactions[conn][:prepare] = opts[:prepare] if supports_prepared_transactions?
+        @transactions[conn][:prepare] = opts[:prepare] if opts[:prepare] && supports_prepared_transactions?
       end
     end    
 

data/lib/sequel/database/schema_generator.rb

@@ -92,9 +92,9 @@ module Sequel
       #          or not allowing NULL values (if false).  If unspecified, will default
       #          to whatever the database default is.
       # :on_delete :: Specify the behavior of this column when being deleted
-      #               (:restrict, cascade, :set_null, :set_default, :no_action).
+      #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :on_update :: Specify the behavior of this column when being updated
-      #               (:restrict, cascade, :set_null, :set_default, :no_action).
+      #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :primary_key :: Make the column as a single primary key column.  This should only
       #                 be used if you have a single, nonautoincrementing primary key column.
       # :size :: The size of the column, generally used with string

data/lib/sequel/database/schema_methods.rb

@@ -6,15 +6,10 @@ module Sequel
     # ---------------------
 
     AUTOINCREMENT = 'AUTOINCREMENT'.freeze
-    CASCADE = 'CASCADE'.freeze
     COMMA_SEPARATOR = ', '.freeze
-    NO_ACTION = 'NO ACTION'.freeze
     NOT_NULL = ' NOT NULL'.freeze
     NULL = ' NULL'.freeze
     PRIMARY_KEY = ' PRIMARY KEY'.freeze
-    RESTRICT = 'RESTRICT'.freeze
-    SET_DEFAULT = 'SET DEFAULT'.freeze
-    SET_NULL = 'SET NULL'.freeze
     TEMPORARY = 'TEMPORARY '.freeze
     UNDERSCORE = '_'.freeze
     UNIQUE = ' UNIQUE'.freeze
@@ -23,6 +18,9 @@ module Sequel
     # The order of column modifiers to use when defining a column.
     COLUMN_DEFINITION_ORDER = [:collate, :default, :null, :unique, :primary_key, :auto_increment, :references]
 
+    # The default options for join table columns.
+    DEFAULT_JOIN_TABLE_COLUMN_OPTIONS = {:null=>false}
+
     # Adds a column to the specified table. This method expects a column name,
     # a datatype and optionally a hash with additional constraints and options:
     #
@@ -76,6 +74,54 @@ module Sequel
       nil
     end
 
+    # Create a join table using a hash of foreign keys to referenced
+    # table names.  Example:
+    #
+    #   create_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+    #   # CREATE TABLE cats_dogs (
+    #   #  cat_id integer NOT NULL REFERENCES cats,
+    #   #  dog_id integer NOT NULL REFERENCES dogs,
+    #   #  PRIMARY KEY (cat_id, dog_id)
+    #   # )
+    #   # CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs(dog_id, cat_id)
+    #
+    # The primary key and index are used so that almost all operations
+    # on the table can benefit from one of the two indexes, and the primary
+    # key ensures that entries in the table are unique, which is the typical
+    # desire for a join table.
+    #
+    # You can provide column options by making the values in the hash
+    # be option hashes, so long as the option hashes have a :table
+    # entry giving the table referenced:
+    #
+    #   create_join_table(:cat_id=>{:table=>:cats, :type=>Bignum}, :dog_id=>:dogs)
+    #   
+    # You can provide a second argument which is a table options hash:
+    #
+    #   create_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :temp=>true)
+    #
+    # Some table options are handled specially:
+    #
+    # :index_options :: The options to pass to the index
+    # :name :: The name of the table to create
+    # :no_index :: Set to true not to create the second index.
+    # :no_primary_key :: Set to true to not create the primary key.
+    def create_join_table(hash, options={})
+      keys = hash.keys.sort_by{|k| k.to_s}
+      create_table(join_table_name(hash, options), options) do
+        keys.each do |key|
+          v = hash[key]
+          unless v.is_a?(Hash)
+            v = {:table=>v}
+          end
+          v = DEFAULT_JOIN_TABLE_COLUMN_OPTIONS.merge(v)
+          foreign_key(key, v)
+        end
+        primary_key(keys) unless options[:no_primary_key]
+        index(keys.reverse, options[:index_options] || {}) unless options[:no_index]
+      end
+    end
+
     # Creates a table with the columns given in the provided block:
     #
     #   DB.create_table :posts do
@@ -102,18 +148,18 @@ module Sequel
     # Forcibly create a table, attempting to drop it if it already exists, then creating it.
     # 
     #   DB.create_table!(:a){Integer :a} 
-    #   # SELECT * FROM a LIMIT a -- check existence
+    #   # SELECT NULL FROM a LIMIT 1 -- check existence
     #   # DROP TABLE a -- drop table if already exists
     #   # CREATE TABLE a (a integer)
     def create_table!(name, options={}, &block)
-      drop_table(name) if table_exists?(name)
+      drop_table?(name)
       create_table(name, options, &block)
     end
     
     # Creates the table unless the table already exists.
     # 
     #   DB.create_table?(:a){Integer :a} 
-    #   # SELECT * FROM a LIMIT a -- check existence
+    #   # SELECT NULL FROM a LIMIT 1 -- check existence
     #   # CREATE TABLE a (a integer) -- if it doesn't already exist
     def create_table?(name, options={}, &block)
       if supports_create_table_if_not_exists?
@@ -161,10 +207,19 @@ module Sequel
     def drop_index(table, columns, options={})
       alter_table(table){drop_index(columns, options)}
     end
+
+    # Drop the join table that would have been created with the
+    # same arguments to create_join_table:
+    #
+    #   drop_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+    #   # DROP TABLE cats_dogs
+    def drop_join_table(hash, options={})
+      drop_table(join_table_name(hash, options), options)
+    end
     
     # Drops one or more tables corresponding to the given names:
     #
-    #   DB.drop_table(:posts)
+    #   DB.drop_table(:posts) # DROP TABLE posts
     #   DB.drop_table(:posts, :comments)
     #   DB.drop_table(:posts, :comments, :cascade=>true)
     def drop_table(*names)
@@ -176,6 +231,26 @@ module Sequel
       nil
     end
     
+    # Drops the table if it already exists.  If it doesn't exist,
+    # does nothing.
+    # 
+    #   DB.drop_table?(:a)
+    #   # SELECT NULL FROM a LIMIT 1 -- check existence
+    #   # DROP TABLE a -- if it already exists
+    def drop_table?(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      if supports_drop_table_if_exists?
+        options = options.merge(:if_exists=>true)
+        names.each do |name|
+          drop_table(name, options)
+        end
+      else
+        names.each do |name|
+          drop_table(name, options) if table_exists?(name)
+        end
+      end
+    end
+    
     # Drops one or more views corresponding to the given names:
     #
     #   DB.drop_view(:cheap_items)
@@ -343,7 +418,7 @@ module Sequel
       sql = " REFERENCES #{quote_schema_table(column[:table])}"
       sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(COMMA_SEPARATOR)})" if column[:key]
       sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
-      sql << " ON UPDATE #{on_delete_clause(column[:on_update])}" if column[:on_update]
+      sql << " ON UPDATE #{on_update_clause(column[:on_update])}" if column[:on_update]
       sql << " DEFERRABLE INITIALLY DEFERRED" if column[:deferrable]
       sql
     end
@@ -408,7 +483,7 @@ module Sequel
 
     # SQL DDL statement to drop the table with the given name.
     def drop_table_sql(name, options)
-      "DROP TABLE #{quote_schema_table(name)}#{' CASCADE' if options[:cascade]}"
+      "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_schema_table(name)}#{' CASCADE' if options[:cascade]}"
     end
     
     # SQL DDL statement to drop a view with the given name.
@@ -440,6 +515,32 @@ module Sequel
       indexes.map{|i| index_definition_sql(table_name, i)}
     end
 
+    # Extract the join table name from the arguments given to create_join_table.
+    # Also does argument validation for the create_join_table method.
+    def join_table_name(hash, options)
+      entries = hash.values
+      raise Error, "must have 2 entries in hash given to (create|drop)_join_table" unless entries.length == 2
+      if options[:name]
+        options[:name]
+      else
+        table_names = entries.map{|e| join_table_name_extract(e)}
+        table_names.map{|t| t.to_s}.sort.join('_')
+      end
+    end
+
+    # Extract an individual join table name, which should either be a string
+    # or symbol, or a hash containing one of those as the value for :table.
+    def join_table_name_extract(entry)
+      case entry
+      when Symbol, String
+        entry
+      when Hash
+        join_table_name_extract(entry[:table])
+      else
+        raise Error, "can't extract table name from #{entry.inspect}"
+      end
+    end
+    
     # SQL DDL ON DELETE fragment to use, based on the given action.
     # The following actions are recognized:
     # 
@@ -450,19 +551,15 @@ module Sequel
     #   but do not allow deferring the integrity check.
     # * :set_default - Set columns referencing this row to their default value.
     # * :set_null - Set columns referencing this row to NULL.
+    #
+    # Any other object given is just converted to a string, with "_" converted to " " and upcased.
     def on_delete_clause(action)
-      case action
-      when :restrict
-        RESTRICT
-      when :cascade
-        CASCADE
-      when :set_null
-        SET_NULL
-      when :set_default
-        SET_DEFAULT
-      else
-        NO_ACTION
-      end
+      action.to_s.gsub("_", " ").upcase
+    end
+
+    # Alias of #on_delete_clause, since the two usually behave the same.
+    def on_update_clause(action)
+      on_delete_clause(action)
     end
     
     # Proxy the quote_schema_table method to the dataset