sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/pg_timestamptz.rb

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+#
+# The pg_timestamptz extension changes the default timestamp
+# type for the database to be +timestamptz+ (+timestamp with time zone+)
+# instead of +timestamp+ (+timestamp without time zone+).  This is
+# recommended if you are dealing with multiple timezones in your application.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :pg_timestamptz
+#
+# Related module: Sequel::Postgres::Timestamptz
+
+#
+module Sequel
+  module Postgres
+    module Timestamptz
+      private
+
+      # Use timestamptz by default for generic timestamp value.
+      def type_literal_generic_datetime(column)
+        :timestamptz
+      end
+    end
+  end
+
+  Database.register_extension(:pg_timestamptz, Postgres::Timestamptz)
+end

data/lib/sequel/extensions/pretty_table.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pretty_table extension adds Sequel::Dataset#print and the
 # Sequel::PrettyTable class for creating nice-looking plain-text
 # tables.  Example:
@@ -18,6 +20,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:pretty_table)
+#
+# Related module: Sequel::DatasetPrinter
 
 #
 module Sequel

data/lib/sequel/extensions/query.rb

@@ -1,10 +1,12 @@
+# frozen-string-literal: true
+#
 # The query extension adds a query method which allows
 # a different way to construct queries instead of the usual
 # method chaining:
 #
 #   dataset = DB[:items].query do
 #     select :x, :y, :z
-#     filter{(x > 1) & (y > 2)}
+#     where{(x > 1) & (y > 2)}
 #     reverse :z
 #   end
 #
@@ -17,6 +19,9 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:query)
+#
+# Related modules: Sequel::DatabaseQuery, Sequel::DatasetQuery,
+# Sequel::Dataset::Query
 
 #
 module Sequel
@@ -32,24 +37,22 @@ module Sequel
   end
 
   module DatasetQuery
-    Dataset.def_mutation_method(:query, :module=>self)
-
     # Translates a query block into a dataset. Query blocks are an
     # alternative to Sequel's usual method chaining, by using
-    # instance_eval with a proxy object:
+    # instance_exec with a proxy object:
     #
     #   dataset = DB[:items].query do
     #     select :x, :y, :z
-    #     filter{(x > 1) & (y > 2)}
+    #     where{(x > 1) & (y > 2)}
     #     reverse :z
     #   end
     #
     # Which is the same as:
     #
-    #  dataset = DB[:items].select(:x, :y, :z).filter{(x > 1) & (y > 2)}.reverse(:z)
+    #  dataset = DB[:items].select(:x, :y, :z).where{(x > 1) & (y > 2)}.reverse(:z)
     def query(&block)
       query = Dataset::Query.new(self)
-      query.instance_eval(&block)
+      query.instance_exec(&block)
       query.dataset
     end
   end
@@ -66,10 +69,12 @@ module Sequel
 
       # Replace the query's dataset with dataset returned by the method call.
       def method_missing(method, *args, &block)
+        # Allow calling private methods, so things like raise works
         @dataset = @dataset.send(method, *args, &block)
         raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
         self
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
     end
   end
 

data/lib/sequel/extensions/round_timestamps.rb

@@ -1,10 +1,11 @@
+# frozen-string-literal: true
+#
 # The round_timestamps extension will automatically round timestamp
 # values to the database's supported level of precision before literalizing
 # them.
 #
-# For example, if the database supports microsecond precision, and you give
-# it a Time value with greater than microsecond precision, it will round it
-# appropriately:
+# For example, if the database supports millisecond precision, and you give
+# it a Time value with microsecond precision, it will round it appropriately:
 #
 #   Time.at(1405341161.917999982833862)
 #   # default: 2014-07-14 14:32:41.917999
@@ -21,12 +22,8 @@
 # To round timestamps for all datasets on a single database:
 #
 #   DB.extension(:round_timestamps)
-
-unless RUBY_VERSION >= '1.9'
-  # :nocov:
-  raise LoadError, 'the round_timestamps extension only works on ruby 1.9+'
-  # :nocov:
-end
+#
+# Related module: Sequel::Dataset::RoundTimestamps
 
 module Sequel
   class Dataset

data/lib/sequel/extensions/run_transaction_hooks.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+#
+# The run_transaction_hooks extension allows for running after_commit or
+# after_rollback extensions before commit or rollback.  It then removes
+# the hook after running it, so it will not be run twice.
+#
+# This extension should only be used in transactional tests where the
+# transaction always rolls back, to test the behavior of the after_commit
+# and after_rollback hooks.  Any other usage is probably a bad idea.
+#
+# Example:
+#
+#   DB.extension :run_transaction_hooks
+#   x = 1
+#   DB.transaction(rollback: :always) do
+#     DB.after_rollback{x = 3}
+#     DB.after_commit{x = 2}
+#
+#     x # => 1
+#     DB.run_after_rollback_hooks
+#     x # => 3
+#     DB.run_after_commit_hooks
+#     x # => 2
+#   end
+#   x # => 2
+
+#
+class Sequel::Database
+  module RunTransactionHooks
+    # Run all savepoint and transaction after_commit hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_commit_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_commit, opts)
+    end
+
+    # Run all savepoint and transaction after_rollback hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_rollback_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_rollback, opts)
+    end
+
+    private
+
+    def _run_transaction_hooks(type, opts)
+      synchronize(opts[:server]) do |conn|
+        unless h = _trans(conn)
+          raise Sequel::Error, "Cannot call run_#{type}_hooks outside of a transaction"
+        end
+
+        if hooks = h[type]
+          hooks.each(&:call)
+          hooks.clear
+        end
+
+        if (savepoints = h[:savepoints])
+          savepoints.each do |savepoint|
+            if hooks = savepoint[type]
+              hooks.each(&:call)
+              hooks.clear
+            end
+          end
+        end
+      end
+    end
+  end
+
+  register_extension(:run_transaction_hooks, RunTransactionHooks)
+end

data/lib/sequel/extensions/s.rb

@@ -0,0 +1,59 @@
+# frozen-string-literal: true
+#
+# The s extension adds Sequel::S, a module containing a private #S
+# method that calls Sequel.expr.  It's designed as a shortcut so
+# that instead of:
+#
+#   Sequel.expr(:column) + 1
+#   # or
+#   Sequel.expr{column + 1}
+#
+# you can just write:
+#
+#   S(:column) + 1
+#   # or
+#   S{column + 1}
+#
+# To load the extension:
+#
+#   Sequel.extension :s
+#
+# Then you can include the Sequel::S module into whatever classes or
+# objects you care about:
+#
+#   Sequel::Model.send(:include, Sequel::S)   # available in model instance methods
+#   Sequel::Model.extend(Sequel::S)           # available in model class methods
+#   Sequel::Dataset.send(:include, Sequel::S) # available in dataset methods
+#
+# or just into Object if you want it available everywhere:
+#
+#   Object.send(:include, Sequel::S)
+#
+# If you are using Ruby 2+, and you would like to use refinements, you
+# can use Sequel::S as a refinement, in which case the private #S method
+# will be available on all objects while the refinement is active.
+#
+#   using Sequel::S
+#
+#   S(:column) + 1
+#
+# Related module: Sequel::S
+
+
+# 
+module Sequel::S
+  private
+
+  # Delegate to Sequel.expr
+  def S(*a, &block)
+    Sequel.expr(*a, &block)
+  end
+
+  # :nocov:
+  if RUBY_VERSION >= '2.0.0'
+  # :nocov:
+    refine Object do
+      include Sequel::S
+    end
+  end
+end

data/lib/sequel/extensions/schema_caching.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The schema_caching extension adds a few methods to Sequel::Database
 # that make it easy to dump the parsed schema information to a file,
 # and load it from that file.  Loading the schema information from a
@@ -41,13 +43,23 @@
 # The cached schema is dumped in Marshal format, since it is the fastest
 # and it handles all ruby objects used in the schema hash.  Because of this,
 # you should not attempt to load the schema from a untrusted file.
+#
+# Related module: Sequel::SchemaCaching
 
 #
 module Sequel
   module SchemaCaching
     # Dump the cached schema to the filename given in Marshal format.
     def dump_schema_cache(file)
-      File.open(file, 'wb'){|f| f.write(Marshal.dump(@schemas))}
+      sch = {}
+      @schemas.each do |k,v|
+        sch[k] = v.map do |c, h|
+          h = Hash[h]
+          h.delete(:callable_default)
+          [c, h]
+        end
+      end
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(sch))}
       nil
     end
 
@@ -61,6 +73,7 @@ module Sequel
     # should be in Marshal format.
     def load_schema_cache(file)
       @schemas = Marshal.load(File.read(file))
+      @schemas.each_value{|v| schema_post_process(v)}
       nil
     end
 

data/lib/sequel/extensions/schema_dumper.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The schema_dumper extension supports dumping tables and indexes
 # in a Sequel::Migration format, so they can be restored on another
 # database (which can be the same type or a different type than
@@ -7,6 +9,8 @@
 # To load the extension:
 #
 #   DB.extension :schema_dumper
+#
+# Related module: Sequel::SchemaDumper
 
 Sequel.extension :eval_inspect
 
@@ -16,45 +20,49 @@ module Sequel
     # be :type.  The other options added should modify that type (e.g. :size).  If a
     # database type is not recognized, return it as a String type.
     def column_schema_to_ruby_type(schema)
-      case schema[:db_type].downcase
-      when /\A(medium|small)?int(?:eger)?(?:\((\d+)\))?( unsigned)?\z/o
+      type = schema[:db_type].downcase
+      if database_type == :oracle
+        type = type.sub(/ not null\z/, '')
+      end
+      case type
+      when /\A(medium|small)?int(?:eger)?(?:\((\d+)\))?( unsigned)?\z/
         if !$1 && $2 && $2.to_i >= 10 && $3
           # Unsigned integer type with 10 digits can potentially contain values which
           # don't fit signed integer type, so use bigint type in target database.
-          {:type=>Bignum}
+          {:type=>:Bignum}
         else
           {:type=>Integer}
         end
-      when /\Atinyint(?:\((\d+)\))?(?: unsigned)?\z/o
+      when /\Atinyint(?:\((\d+)\))?(?: unsigned)?\z/
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
-      when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/o
-        {:type=>Bignum}
-      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/o
+      when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/
+        {:type=>:Bignum}
+      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\))(?: unsigned)?\z/
         {:type=>Float}
-      when 'boolean', 'bit'
+      when 'boolean', 'bit', 'bool'
         {:type=>TrueClass}
-      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
+      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/
         {:type=>String, :text=>true}
       when 'date'
         {:type=>Date}
-      when /\A(?:small)?datetime\z/o
+      when /\A(?:small)?datetime\z/
         {:type=>DateTime}
-      when /\Atimestamp(?:\((\d+)\))?(?: with(?:out)? time zone)?\z/o
+      when /\Atimestamp(?:\((\d+)\))?(?: with(?:out)? time zone)?\z/
         {:type=>DateTime, :size=>($1.to_i if $1)}
-      when /\Atime(?: with(?:out)? time zone)?\z/o
+      when /\Atime(?: with(?:out)? time zone)?\z/
         {:type=>Time, :only_time=>true}
-      when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
+      when /\An?char(?:acter)?(?:\((\d+)\))?\z/
         {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
-      when /\A(?:n?varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
+      when /\A(?:n?varchar2?|character varying|bpchar|string)(?:\((\d+)\))?\z/
         {:type=>String, :size=>($1.to_i if $1)}
-      when /\A(?:small)?money\z/o
+      when /\A(?:small)?money\z/
         {:type=>BigDecimal, :size=>[19,2]}
-      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o
+      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?(?: unsigned)?\z/
         s = [($1.to_i if $1), ($2.to_i if $2)].compact
         {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
-      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/o
+      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/
         {:type=>File, :size=>($1.to_i if $1)}
-      when /\A(?:year|(?:int )?identity)\z/o
+      when /\A(?:year|(?:int )?identity)\z/
         {:type=>Integer}
       else
         {:type=>String}
@@ -62,7 +70,7 @@ module Sequel
     end
 
     # Dump foreign key constraints for all tables as a migration. This complements
-    # the :foreign_keys=>false option to dump_schema_migration. This only dumps
+    # the foreign_keys: false option to dump_schema_migration. This only dumps
     # the constraints (not the columns) using alter_table/add_foreign_key with an
     # array of columns.
     #
@@ -73,14 +81,14 @@ module Sequel
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by(&:to_s).map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+#{ts.sort.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
     end
 
     # Dump indexes for all tables as a migration.  This complements
-    # the :indexes=>false option to dump_schema_migration. Options:
+    # the indexes: false option to dump_schema_migration. Options:
     # :same_db :: Create a dump for the same database type, so
     #             don't ignore errors if the index statements fail.
     # :index_names :: If set to false, don't record names of indexes. If
@@ -91,13 +99,13 @@ END_MIG
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by(&:to_s).map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+#{ts.sort.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
     end
 
-    # Return a string that contains a Sequel::Migration subclass that when
+    # Return a string that contains a Sequel migration that when
     # run would recreate the database structure. Options:
     # :same_db :: Don't attempt to translate database types to ruby types.
     #             If this isn't set to true, all database types will be translated to
@@ -124,14 +132,14 @@ END_MIG
         # Handle skipped foreign keys by adding them at the end via
         # alter_table/add_foreign_key.  Note that skipped foreign keys
         # probably result in a broken down migration.
-        sfka = sfk.sort_by{|table, fks| table.to_s}.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
-        sfka.join("\n\n").gsub(/^/o, '    ') unless sfka.empty?
+        sfka = sfk.sort.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
+        sfka.join("\n\n").gsub(/^/, '    ') unless sfka.empty?
       end
 
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/o, '    ')}#{"\n    \n" if skipped_fks}#{skipped_fks}
+#{ts.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/, '    ')}#{"\n    \n" if skipped_fks}#{skipped_fks}
   end
 end
 END_MIG
@@ -140,10 +148,9 @@ END_MIG
     # Return a string with a create table block that will recreate the given
     # table's schema.  Takes the same options as dump_schema_migration.
     def dump_table_schema(table, options=OPTS)
-      table = table.value.to_s if table.is_a?(SQL::Identifier)
       gen = dump_table_generator(table, options)
       commands = [gen.dump_columns, gen.dump_constraints, gen.dump_indexes].reject{|x| x == ''}.join("\n\n")
-      "create_table(#{table.inspect}#{', :ignore_index_errors=>true' if !options[:same_db] && options[:indexes] != false && !gen.indexes.empty?}) do\n#{commands.gsub(/^/o, '  ')}\nend"
+      "create_table(#{table.inspect}#{', :ignore_index_errors=>true' if !options[:same_db] && options[:indexes] != false && !gen.indexes.empty?}) do\n#{commands.gsub(/^/, '  ')}\nend"
     end
 
     private
@@ -160,12 +167,22 @@ END_MIG
       end
     end
 
-    # Recreate the column in the passed Schema::Generator from the given name and parsed database schema.
+    # Recreate the column in the passed Schema::CreateTableGenerator from the given name and parsed database schema.
     def recreate_column(name, schema, gen, options)
       if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
         type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
         [:table, :key, :on_delete, :on_update, :deferrable].each{|f| type_hash[f] = schema[f] if schema[f]}
         if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
+          type_hash.delete(:type)
+        elsif options[:same_db] && type_hash == {:type=>type_literal_generic_bignum_symbol(type_hash).to_s}
+          type_hash[:type] = :Bignum
+        end
+
+        unless gen.columns.empty?
+          type_hash[:keep_order] = true
+        end
+
+        if type_hash.empty?
           gen.primary_key(name)
         else
           gen.primary_key(name, type_hash)
@@ -182,12 +199,18 @@ END_MIG
         end
         type = col_opts.delete(:type)
         col_opts.delete(:size) if col_opts[:size].nil?
-        col_opts[:default] = if schema[:ruby_default].nil?
-          column_schema_to_ruby_default_fallback(schema[:default], options)
+        if schema[:generated]
+          if options[:same_db] && database_type == :postgres
+            col_opts[:generated_always_as] = column_schema_to_ruby_default_fallback(schema[:default], options)
+          end
         else
-          schema[:ruby_default]
+          col_opts[:default] = if schema[:ruby_default].nil?
+            column_schema_to_ruby_default_fallback(schema[:default], options)
+          else
+            schema[:ruby_default]
+          end
+          col_opts.delete(:default) if col_opts[:default].nil?
         end
-        col_opts.delete(:default) if col_opts[:default].nil?
         col_opts[:null] = false if schema[:allow_null] == false
         if table = schema[:table]
           [:key, :on_delete, :on_update, :deferrable].each{|f| col_opts[f] = schema[f] if schema[f]}
@@ -195,7 +218,7 @@ END_MIG
           gen.foreign_key(name, table, col_opts)
         else
           gen.column(name, type, col_opts)
-          if [Integer, Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
+          if [Integer, :Bignum, Float, BigDecimal].include?(type) && schema[:db_type] =~ / unsigned\z/io
             gen.check(Sequel::SQL::Identifier.new(name) >= 0)
           end
         end
@@ -205,9 +228,10 @@ END_MIG
     # For the table and foreign key metadata array, return an alter_table
     # string that would add the foreign keys if run in a migration.
     def dump_add_fk_constraints(table, fks)
-      sfks = "alter_table(#{table.inspect}) do\n"
+      sfks = String.new
+      sfks << "alter_table(#{table.inspect}) do\n"
       sfks << create_table_generator do
-        fks.sort_by{|fk| fk[:columns].map(&:to_s)}.each do |fk|
+        fks.sort_by{|fk| fk[:columns]}.each do |fk|
           foreign_key fk[:columns], fk
         end
       end.dump_constraints.gsub(/^foreign_key /, '  add_foreign_key ')
@@ -218,7 +242,7 @@ END_MIG
     # string that would add the foreign keys if run in a migration.
     def dump_table_foreign_keys(table, options=OPTS)
       if supports_foreign_key_parsing?
-        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns].map(&:to_s)}
+        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns]}
       end
 
       if fks.nil? || fks.empty?
@@ -228,19 +252,17 @@ END_MIG
       end
     end
 
-    # Return a Schema::Generator object that will recreate the
+    # Return a Schema::CreateTableGenerator object that will recreate the
     # table's schema.  Takes the same options as dump_schema_migration.
     def dump_table_generator(table, options=OPTS)
-      table = table.value.to_s if table.is_a?(SQL::Identifier)
-      raise(Error, "must provide table as a Symbol, String, or Sequel::SQL::Identifier") unless [String, Symbol].any?{|c| table.is_a?(c)}
-      s = schema(table).dup
+      s = schema(table, options).dup
       pks = s.find_all{|x| x.last[:primary_key] == true}.map(&:first)
       options = options.merge(:single_pk=>true) if pks.length == 1
       m = method(:recreate_column)
       im = method(:index_to_generator_opts)
 
       if options[:indexes] != false && supports_index_parsing?
-        indexes = indexes(table).sort_by{|k,v| k.to_s}
+        indexes = indexes(table).sort
       end
 
       if options[:foreign_keys] != false && supports_foreign_key_parsing?
@@ -280,7 +302,7 @@ END_MIG
     # creating the index migration.
     def dump_table_indexes(table, meth, options=OPTS)
       if supports_index_parsing?
-        indexes = indexes(table).sort_by{|k,v| k.to_s}
+        indexes = indexes(table).sort
       else
         return ''
       end
@@ -292,7 +314,7 @@ END_MIG
       gen.dump_indexes(meth=>table, :ignore_errors=>!options[:same_db])
     end
 
-    # Convert the parsed index information into options to the Generators index method. 
+    # Convert the parsed index information into options to the CreateTableGenerator's index method. 
     def index_to_generator_opts(table, name, index_opts, options=OPTS)
       h = {}
       if options[:index_names] != false && default_index_name(table, index_opts[:columns]) != name.to_s
@@ -319,7 +341,7 @@ END_MIG
         options[:skipped_foreign_keys] = skipped_foreign_keys
         tables
       else
-        tables.sort_by(&:to_s)
+        tables.sort
       end
     end
 
@@ -344,14 +366,14 @@ END_MIG
           # outstanding foreign keys and skipping those foreign keys.
           # The skipped foreign keys will be added at the end of the
           # migration.
-          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table.to_s]}.first
+          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table]}.first
           skip_fks_hash = skipped_foreign_keys[skip_table] = {}
           skip_fks.each{|fk| skip_fks_hash[fk[:columns]] = fk}
           this_loop << skip_table
         end
 
         # Add sorted tables from this loop to the final list
-        sorted_tables.concat(this_loop.sort_by(&:to_s))
+        sorted_tables.concat(this_loop.sort)
 
         # Remove tables that were handled this loop
         this_loop.each{|t| table_fks.delete(t)}
@@ -368,7 +390,7 @@ END_MIG
   end
 
   module Schema
-    class Generator
+    class CreateTableGenerator
       # Dump this generator's columns to a string that could be evaled inside
       # another instance to represent the same columns
       def dump_columns
@@ -378,7 +400,7 @@ END_MIG
           x.delete(:on_delete) if x[:on_delete] == :no_action
           x.delete(:on_update) if x[:on_update] == :no_action
         end
-        if pkn = primary_key_name
+        if (pkn = primary_key_name) && !@primary_key[:keep_order]
           cols.delete_if{|x| x[:name] == pkn}
           pk = @primary_key.dup
           pkname = pk.delete(:name)
@@ -391,11 +413,17 @@ END_MIG
           strings << if table = c.delete(:table)
             c.delete(:type) if c[:type] == Integer || c[:type] == 'integer'
             "foreign_key #{name.inspect}, #{table.inspect}#{opts_inspect(c)}"
+          elsif pkn == name
+            @db.serial_primary_key_options.each{|k,v| c.delete(k) if v == c[k]}
+            "primary_key #{name.inspect}#{opts_inspect(c)}"
           else
             type = c.delete(:type)
             opts = opts_inspect(c)
-            if type.is_a?(Class)
+            case type
+            when Class
               "#{type.name} #{name.inspect}#{opts}"
+            when :Bignum
+              "Bignum #{name.inspect}#{opts}"
             else
               "column #{name.inspect}, #{type.inspect}#{opts}"
             end
@@ -436,11 +464,11 @@ END_MIG
 
       # Dump this generator's indexes to a string that could be evaled inside
       # another instance to represent the same indexes. Options:
-      # * :add_index - Use add_index instead of index, so the methods
-      #   can be called outside of a generator but inside a migration.
-      #   The value of this option should be the table name to use.
-      # * :drop_index - Same as add_index, but create drop_index statements.
-      # * :ignore_errors - Add the ignore_errors option to the outputted indexes
+      # :add_index :: Use add_index instead of index, so the methods
+      #               can be called outside of a generator but inside a migration.
+      #               The value of this option should be the table name to use.
+      # :drop_index :: Same as add_index, but create drop_index statements.
+      # :ignore_errors :: Add the ignore_errors option to the outputted indexes
       def dump_indexes(options=OPTS)
         is = indexes.map do |c|
           c = c.dup