sequel 5.101.0 → 5.104.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9de2d20e1483de5f15a285b695d5eab98601c26f1e711e378de1a03331f197a1
-  data.tar.gz: 4d7df1811d7242dad22f6c9968fb43feecb5a86fd814aa2ba7434bdb44369cb8
+  metadata.gz: a28329284b305f2ea739dc8ca05aa690db11c9c68c0dcd5fb47035ee621edbf9
+  data.tar.gz: 8cdf6a6239baddff4fc926718409413713801d4d49481b7f151a439fa8a8bbe1
 SHA512:
-  metadata.gz: a9aa7a3bd15f4f35457aace92b68b4734d367273996dc605d80adbe87bca1c945fc484571cad90149e69807980eea2f8b2a6a6fea85a4a0670c10a082a056a03
-  data.tar.gz: ca5c1eb34d71d16660a0b5eb2b9e5b4c784f06d6e4f89b036f00a62f31b57d564f071b8346bdcb9ebd9cced7bcfbe429e2c50bcda1b8b150d723b1e59105c474
+  metadata.gz: 9f1f61fc96b631a8c081b831fa8a9dfa962908bcb11bde6975cc75c234e416941492ac140b6b9d995aa8fcd84ffec0c519eb11e4aba43b16fe779cf66e23973e
+  data.tar.gz: ae638f7d62552732ebe9fd7af00fb3bdb931c078cabb3cc134e3d370a3104b5ce711a454d57f14e427fb7e522b95755366d7128cb3d1de3f325da19dd3e8ce5f

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2023 Jeremy Evans
+Copyright (c) 2008-2026 Jeremy Evans and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/lib/sequel/adapters/jdbc/derby.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+# SEQUEL6: Remove
+
 Sequel::JDBC.load_driver('Java::OrgApacheDerbyJdbc::EmbeddedDriver', :Derby)
 require_relative 'transactions'
 require_relative '../utils/columns_limit_1'

data/lib/sequel/adapters/jdbc/h2.rb

@@ -18,7 +18,7 @@ module Sequel
         include AutoCastDateAndTime
 
         def commit_prepared_transaction(transaction_id, opts=OPTS)
-          run("COMMIT TRANSACTION #{transaction_id}", opts)
+          run("COMMIT TRANSACTION #{transaction_id}".freeze, opts)
         end
 
         def database_type
@@ -36,7 +36,7 @@ module Sequel
         end
 
         def rollback_prepared_transaction(transaction_id, opts=OPTS)
-          run("ROLLBACK TRANSACTION #{transaction_id}", opts)
+          run("ROLLBACK TRANSACTION #{transaction_id}".freeze, opts)
         end
 
         # H2 uses an IDENTITY type for primary keys

data/lib/sequel/adapters/postgres.rb

@@ -727,7 +727,7 @@ module Sequel
               prepared_args << y
               i = prepared_args.length
             end
-            LiteralString.new("#{prepared_arg_placeholder}#{i}")
+            LiteralString.new("#{prepared_arg_placeholder}#{i}".freeze)
           end
         end
 

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

@@ -106,7 +106,7 @@ module Sequel
           values << value
         end
 
-        sql = "DECLARE #{declarations.join(', ')}; EXECUTE @RC = #{name} #{values.join(', ')}; SELECT #{names.join(', ')}"
+        sql = "DECLARE #{declarations.join(', ')}; EXECUTE @RC = #{name} #{values.join(', ')}; SELECT #{names.join(', ')}".freeze
 
         ds = dataset.with_sql(sql)
         ds = ds.server(opts[:server]) if opts[:server]
@@ -400,7 +400,7 @@ module Sequel
       # Error if a string is given.
       def create_table_as(name, ds, options)
         raise(Error, "must provide dataset instance as value of create_table :as option on MSSQL") unless ds.is_a?(Sequel::Dataset)
-        run(ds.into(name).sql)
+        run(ds.into(name).sql.freeze)
       end
     
       DATABASE_ERROR_REGEXPS = {
@@ -878,7 +878,7 @@ module Sequel
         elsif @opts[:output]
           # no transaction: our multi_insert_sql_strategy should guarantee
           # that there's only ever a single statement.
-          sql = multi_insert_sql(columns, values)[0]
+          sql = multi_insert_sql(columns, values)[0].freeze
           naked.with_sql(sql).map{|v| v.length == 1 ? v.values.first : v}
         else
           super

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

@@ -40,7 +40,7 @@ module Sequel
       end
 
       def commit_prepared_transaction(transaction_id, opts=OPTS)
-        run("XA COMMIT #{literal(transaction_id)}", opts)
+        run("XA COMMIT #{literal(transaction_id)}".freeze, opts)
       end
 
       def database_type
@@ -103,7 +103,7 @@ module Sequel
           sql += " FROM #{literal(schema)}"
         end
 
-        metadata_dataset.with_sql(sql).each do |r|
+        metadata_dataset.with_sql(sql.freeze).each do |r|
           name = r[:Key_name]
           next if name == 'PRIMARY'
           name = m.call(name)
@@ -115,7 +115,7 @@ module Sequel
       end
 
       def rollback_prepared_transaction(transaction_id, opts=OPTS)
-        run("XA ROLLBACK #{literal(transaction_id)}", opts)
+        run("XA ROLLBACK #{literal(transaction_id)}".freeze, opts)
       end
 
       # Whether the database is MariaDB and not MySQL
@@ -780,7 +780,8 @@ module Sequel
         # Load the PrettyTable class, needed for explain output
         Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
 
-        ds = db.send(:metadata_dataset).with_sql(((opts[:extended] && (db.mariadb? || db.server_version < 50700)) ? 'EXPLAIN EXTENDED ' : 'EXPLAIN ') + select_sql).naked
+        sql = ((opts[:extended] && (db.mariadb? || db.server_version < 50700)) ? 'EXPLAIN EXTENDED ' : 'EXPLAIN ') + select_sql
+        ds = db.send(:metadata_dataset).with_sql(sql.freeze).naked
         rows = ds.all
         Sequel::PrettyTable.string(rows, ds.columns)
       end

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

@@ -339,7 +339,7 @@ module Sequel
       end
 
       def commit_prepared_transaction(transaction_id, opts=OPTS)
-        run("COMMIT PREPARED #{literal(transaction_id)}", opts)
+        run("COMMIT PREPARED #{literal(transaction_id)}".freeze, opts)
       end
 
       # A hash of metadata for CHECK constraints on the table.
@@ -416,7 +416,7 @@ module Sequel
         return if already_identity
 
         transaction(server_hash) do
-          run("ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(column)} DROP DEFAULT", server_hash)
+          run("ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(column)} DROP DEFAULT".freeze, server_hash)
 
           ds.from(:pg_depend).
             where(:classid=>pg_class, :objid=>seq_oid, :objsubid=>0, :deptype=>'a').
@@ -453,7 +453,7 @@ module Sequel
       #                 often used here if :security_definer is used.
       #         :strict :: Makes the function return NULL when any argument is NULL.
       def create_function(name, definition, opts=OPTS)
-        self << create_function_sql(name, definition, opts)
+        self << create_function_sql(name, definition, opts).freeze
       end
 
       # Create the procedural language in the database. Arguments:
@@ -464,7 +464,7 @@ module Sequel
       #         :trusted :: Marks the language being created as trusted, allowing unprivileged users to create functions using this language.
       #         :validator :: The name of previously registered function used as a validator of functions defined in this language.
       def create_language(name, opts=OPTS)
-        self << create_language_sql(name, opts)
+        self << create_language_sql(name, opts).freeze
       end
 
       # Create a schema in the database. Arguments:
@@ -473,7 +473,7 @@ module Sequel
       #         :if_not_exists :: Don't raise an error if the schema already exists (PostgreSQL 9.3+)
       #         :owner :: The owner to set for the schema (defaults to current user if not specified)
       def create_schema(name, opts=OPTS)
-        self << create_schema_sql(name, opts)
+        self << create_schema_sql(name, opts).freeze
       end
 
       # Support partitions of tables using the :partition_of option.
@@ -509,7 +509,7 @@ module Sequel
       #         :replace :: Replace the trigger with the same name if it already exists (PostgreSQL 14+).
       #         :when :: A filter to use for the trigger
       def create_trigger(table, name, function, opts=OPTS)
-        self << create_trigger_sql(table, name, function, opts)
+        self << create_trigger_sql(table, name, function, opts).freeze
       end
 
       def database_type
@@ -542,7 +542,7 @@ module Sequel
       #              default is plpgsql.  Can be specified as a string or a symbol.
       def do(code, opts=OPTS)
         language = opts[:language]
-        run "DO #{"LANGUAGE #{literal(language.to_s)} " if language}#{literal(code)}"
+        run "DO #{"LANGUAGE #{literal(language.to_s)} " if language}#{literal(code)}".freeze
       end
 
       # Drops the function from the database. Arguments:
@@ -552,7 +552,7 @@ module Sequel
       #         :cascade :: Drop other objects depending on this function.
       #         :if_exists :: Don't raise an error if the function doesn't exist.
       def drop_function(name, opts=OPTS)
-        self << drop_function_sql(name, opts)
+        self << drop_function_sql(name, opts).freeze
       end
 
       # Drops a procedural language from the database.  Arguments:
@@ -561,7 +561,7 @@ module Sequel
       #         :cascade :: Drop other objects depending on this function.
       #         :if_exists :: Don't raise an error if the function doesn't exist.
       def drop_language(name, opts=OPTS)
-        self << drop_language_sql(name, opts)
+        self << drop_language_sql(name, opts).freeze
       end
 
       # Drops a schema from the database.  Arguments:
@@ -570,7 +570,7 @@ module Sequel
       #         :cascade :: Drop all objects in this schema.
       #         :if_exists :: Don't raise an error if the schema doesn't exist.
       def drop_schema(name, opts=OPTS)
-        self << drop_schema_sql(name, opts)
+        self << drop_schema_sql(name, opts).freeze
         remove_all_cached_schemas
       end
 
@@ -581,7 +581,7 @@ module Sequel
       #         :cascade :: Drop other objects depending on this function.
       #         :if_exists :: Don't raise an error if the function doesn't exist.
       def drop_trigger(table, name, opts=OPTS)
-        self << drop_trigger_sql(table, name, opts)
+        self << drop_trigger_sql(table, name, opts).freeze
       end
 
       # Return full foreign key information using the pg system tables, including
@@ -745,7 +745,7 @@ module Sequel
       # name :: Current name of the schema
       # opts :: New name for the schema
       def rename_schema(name, new_name)
-        self << rename_schema_sql(name, new_name)
+        self << rename_schema_sql(name, new_name).freeze
         remove_all_cached_schemas
       end
 
@@ -756,7 +756,7 @@ module Sequel
       #   DB.refresh_view(:items_view, concurrently: true)
       #   # REFRESH MATERIALIZED VIEW CONCURRENTLY items_view
       def refresh_view(name, opts=OPTS)
-        run "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if opts[:concurrently]} #{quote_schema_table(name)}"
+        run "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if opts[:concurrently]} #{quote_schema_table(name)}".freeze
       end
       
       # Reset the primary key sequence for the given table, basing it on the
@@ -769,7 +769,7 @@ module Sequel
         table = Sequel.qualify(s, t) if s
 
         if server_version >= 100000
-          seq_ds = metadata_dataset.from(:pg_sequence).where(:seqrelid=>regclass_oid(LiteralString.new(seq)))
+          seq_ds = metadata_dataset.from(:pg_sequence).where(:seqrelid=>regclass_oid(LiteralString.new(seq.freeze)))
           increment_by = :seqincrement
           min_value = :seqmin
         # :nocov:
@@ -784,7 +784,7 @@ module Sequel
       end
 
       def rollback_prepared_transaction(transaction_id, opts=OPTS)
-        run("ROLLBACK PREPARED #{literal(transaction_id)}", opts)
+        run("ROLLBACK PREPARED #{literal(transaction_id)}".freeze, opts)
       end
 
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
@@ -1469,7 +1469,7 @@ module Sequel
 
       def column_references_add_period(cols)
         cols= cols.dup
-        cols[-1] = Sequel.lit("PERIOD #{quote_identifier(cols[-1])}")
+        cols[-1] = Sequel.lit("PERIOD #{quote_identifier(cols[-1])}".freeze)
         cols
       end
   

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

@@ -195,7 +195,7 @@ module Sequel
 
       # Dataset used for parsing schema
       def _parse_pragma_ds(table_name, opts)
-        metadata_dataset.with_sql("PRAGMA table_#{'x' if sqlite_version > 33100}info(?)", input_identifier_meth(opts[:dataset]).call(table_name))
+        metadata_dataset.with_sql("PRAGMA table_#{'x' if sqlite_version > 33100}info(?)".freeze, input_identifier_meth(opts[:dataset]).call(table_name))
       end
 
       # Run all alter_table commands in a transaction.  This is technically only
@@ -407,7 +407,7 @@ module Sequel
       def defined_columns_for(table)
         cols = parse_pragma(table, OPTS)
         cols.each do |c|
-          c[:default] = LiteralString.new(c[:default]) if c[:default]
+          c[:default] = LiteralString.new(c[:default]).freeze if c[:default]
           c[:type] = c[:db_type]
         end
         cols
@@ -684,7 +684,7 @@ module Sequel
         # Load the PrettyTable class, needed for explain output
         Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
 
-        ds = db.send(:metadata_dataset).clone(:sql=>"EXPLAIN #{select_sql}")
+        ds = db.send(:metadata_dataset).clone(:sql=>"EXPLAIN #{select_sql}".freeze)
         rows = ds.all
         Sequel::PrettyTable.string(rows, ds.columns)
       end

data/lib/sequel/adapters/sqlite.rb

@@ -388,7 +388,7 @@ module Sequel
         # SQLite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
-          LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
+          LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}".freeze)
         end
       end
       

data/lib/sequel/adapters/tinytds.rb

@@ -205,7 +205,7 @@ module Sequel
         private
         
         def prepared_arg(k)
-          LiteralString.new("@#{k.to_s.gsub('.', '__')}")
+          LiteralString.new("@#{k.to_s.gsub('.', '__')}".freeze)
         end
       end
       

data/lib/sequel/connection_pool/sharded_timed_queue.rb

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

data/lib/sequel/connection_pool/timed_queue.rb

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

data/lib/sequel/connection_pool.rb

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

data/lib/sequel/database/schema_generator.rb

@@ -3,6 +3,33 @@
 module Sequel
   # The Schema module holds the schema generators.
   module Schema
+    module ColumnOptionMerger
+      private
+
+      # Merge given options into the column's default options. For backwards compatibility,
+      # the options take priority, but in cases where the option value overrides the argument
+      # value, and the values are different, we warn as this is likely to be an error in the
+      # code.
+      def _merge_column_options(defaults, opts)
+        defaults.merge!(opts) do |k, defv, v|
+          unless defv == v
+            # :nocov:
+            if RUBY_VERSION >= "3.2"
+            # :nocov:
+              caller_loc = Thread.each_caller_location do |loc|
+                break loc unless loc.path == __FILE__
+              end
+              caller_loc &&= "#{caller_loc.path}:#{caller_loc.lineno}: "
+            end
+            warn("#{caller_loc}#{k.inspect} option value (#{v.inspect}) overrides argument value (#{defv.inspect})")
+          end
+
+          v
+        end
+      end
+    end
+    private_constant :ColumnOptionMerger
+
     # Schema::CreateTableGenerator is an internal class that the user is not expected
     # to instantiate directly.  Instances are created by Database#create_table.
     # It is used to specify table creation parameters.  It takes a Database
@@ -17,6 +44,8 @@ module Sequel
     # For more information on Sequel's support for schema modification, see
     # the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     class CreateTableGenerator
+      include ColumnOptionMerger
+
       # Classes specifying generic types that Sequel will convert to database-specific types.
       GENERIC_TYPES=%w'String Integer Float Numeric BigDecimal Date DateTime Time File TrueClass FalseClass'.freeze
       
@@ -173,13 +202,13 @@ module Sequel
       # :clustered :: When using :primary_key or :unique, marks the primary key or unique
       #               constraint as CLUSTERED (if true), or NONCLUSTERED (if false).
       def column(name, type, opts = OPTS)
-        columns << {:name => name, :type => type}.merge!(opts)
+        columns << _merge_column_options({:name => name, :type => type}, opts)
         if index_opts = opts[:index]
           index(name, index_opts.is_a?(Hash) ? index_opts : OPTS)
         end
         nil
       end
-      
+
       # Adds a named CHECK constraint (or unnamed if name is nil),
       # with the given block or args. To provide options for the constraint, pass
       # a hash as the first argument.
@@ -246,7 +275,7 @@ module Sequel
           opts.merge(:table=>table)
         end
         return composite_foreign_key(name, opts) if name.is_a?(Array)
-        column(name, Integer, opts)
+        column(name, opts.fetch(:type, Integer), opts)
       end
 
       # Add a full text index on the given columns.
@@ -429,6 +458,8 @@ module Sequel
     # For more information on Sequel's support for schema modification, see
     # the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
     class AlterTableGenerator
+      include ColumnOptionMerger
+
       # An array of operations to perform
       attr_reader :operations
       
@@ -454,7 +485,7 @@ module Sequel
       # :after :: The name of an existing column that the new column should be positioned after
       # :first :: Create this new column before all other existing columns
       def add_column(name, type, opts = OPTS)
-        op = {:op => :add_column, :name => name, :type => type}.merge!(opts)
+        op = _merge_column_options({:op => :add_column, :name => name, :type => type}, opts)
         index_opts = op.delete(:index)
         @operations << op
         add_index(name, index_opts.is_a?(Hash) ? index_opts : OPTS) if index_opts
@@ -519,7 +550,7 @@ module Sequel
       #               sense when using an array of columns.
       def add_foreign_key(name, table, opts = OPTS)
         return add_composite_foreign_key(name, table, opts) if name.is_a?(Array)
-        add_column(name, Integer, {:table=>table}.merge!(opts))
+        add_column(name, opts.fetch(:type, Integer), {:table=>table}.merge!(opts))
       end
       
       # Add a full text index on the given columns.

data/lib/sequel/database/schema_methods.rb

@@ -819,7 +819,7 @@ module Sequel
     # SELECT sql statement.
     def create_table_as(name, sql, options)
       sql = sql.sql if sql.is_a?(Sequel::Dataset)
-      run(create_table_as_sql(name, sql, options))
+      run(create_table_as_sql(name, sql, options).freeze)
     end
     
     # SQL statement for creating a table from the result of a SELECT statement.

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -117,6 +117,8 @@ module Sequel
           frags << final_sql
           prepared_sql << final_sql
 
+          frags.each(&:freeze)
+          frags.freeze
           [prepared_sql, frags]
         end
 
@@ -125,6 +127,7 @@ module Sequel
           @argn = -1
           @args = []
           ds = yield self, dataset
+          ds.opts[:sql].freeze
           sql = ds.clone(:placeholder_literalizer=>self).sql
 
           last_offset = 0