sequel 3.11.0 → 3.12.0

data/lib/sequel/dataset/actions.rb

@@ -7,6 +7,12 @@ module Sequel
     # they should be the last method called.
     # ---------------------
     
+    # Action methods defined by Sequel that execute code on the database.
+    ACTION_METHODS = %w'<< [] []= all avg count columns columns! delete each
+    empty? fetch_rows first get import insert insert_multiple interval last
+    map max min multi_insert range select_hash select_map select_order_map
+    set single_record single_value sum to_csv to_hash truncate update'.map{|x| x.to_sym}
+
     # Alias for insert, but not aliased directly so subclasses
     # don't have to override both methods.
     def <<(*args)
@@ -104,7 +110,7 @@ module Sequel
     # Executes a select query and fetches records, passing each record to the
     # supplied block.  The yielded records should be hashes with symbol keys.
     def fetch_rows(sql, &block)
-      raise NotImplementedError, NOTIMPL_MSG
+      raise NotImplemented, NOTIMPL_MSG
     end
     
     # If a integer argument is
@@ -156,7 +162,8 @@ module Sequel
     end
     
     # Inserts multiple records into the associated table. This method can be
-    # to efficiently insert a large amounts of records into a table. Inserts
+    # used to efficiently insert a large number of records into a table in a
+    # single query if the database supports it. Inserts
     # are automatically wrapped in a transaction.
     # 
     # This method is called with a columns array and an array of value arrays:

data/lib/sequel/dataset/misc.rb

@@ -49,6 +49,11 @@ module Sequel
       db.servers.each{|s| yield server(s)}
     end
    
+    # Alias of first_source_alias
+    def first_source
+      first_source_alias
+    end
+
     # The first source (primary table) for this dataset.  If the dataset doesn't
     # have a table, raises an error.  If the table is aliased, returns the aliased name.
     def first_source_alias
@@ -66,7 +71,6 @@ module Sequel
         s
       end
     end
-    alias first_source first_source_alias
     
     # The first source (primary table) for this dataset.  If the dataset doesn't
     # have a table, raises an error.  If the table is aliased, returns the original
@@ -116,4 +120,4 @@ module Sequel
       end
     end
   end
-end
+end

data/lib/sequel/dataset/mutation.rb

@@ -5,16 +5,8 @@ module Sequel
     # These methods modify the receiving dataset and should be used with care.
     # ---------------------
     
-    # All methods that should have a ! method added that modifies
-    # the receiver.
-    MUTATION_METHODS = %w'add_graph_aliases and cross_join distinct except exclude
-    filter for_update from from_self full_join full_outer_join graph
-    group group_and_count group_by having inner_join intersect invert join join_table left_join
-    left_outer_join limit lock_style naked natural_full_join natural_join
-    natural_left_join natural_right_join or order order_by order_more paginate qualify query
-    reverse reverse_order right_join right_outer_join select select_all select_append select_more server
-    set_defaults set_graph_aliases set_overrides unfiltered ungraphed ungrouped union
-    unlimited unordered where with with_recursive with_sql'.collect{|x| x.to_sym}
+    # All methods that should have a ! method added that modifies the receiver.
+    MUTATION_METHODS = QUERY_METHODS
     
     # Setup mutation (e.g. filter!) methods.  These operate the same as the
     # non-! methods, but replace the options of the current dataset with the
@@ -61,4 +53,4 @@ module Sequel
       self
     end
   end
-end
+end

data/lib/sequel/dataset/query.rb

@@ -4,6 +4,7 @@ module Sequel
     # :section: Methods that return modified datasets
     # These methods all return modified copies of the receiver.
     # ---------------------
+
     # The dataset options that require the removal of cached columns
     # if changed.
     COLUMN_CHANGE_OPTS = [:select, :sql, :from, :join].freeze
@@ -23,6 +24,17 @@ module Sequel
     # if called with a block.
     UNCONDITIONED_JOIN_TYPES = [:natural, :natural_left, :natural_right, :natural_full, :cross]
     
+    # All methods that return modified datasets with a joined table added.
+    JOIN_METHODS = (CONDITIONED_JOIN_TYPES + UNCONDITIONED_JOIN_TYPES).map{|x| "#{x}_join".to_sym} + [:join, :join_table]
+    
+    # Methods that return modified datasets
+    QUERY_METHODS = %w'add_graph_aliases and distinct except exclude
+    filter for_update from from_self graph grep group group_and_count group_by having intersect invert
+    limit lock_style naked or order order_append order_by order_more order_prepend paginate qualify query
+    reverse reverse_order select select_all select_append select_more server
+    set_defaults set_graph_aliases set_overrides unfiltered ungraphed ungrouped union
+    unlimited unordered where with with_recursive with_sql'.collect{|x| x.to_sym} + JOIN_METHODS
+
     # Adds an further filter to an existing filter using AND. If no filter 
     # exists an error is raised. This method is identical to #filter except
     # it expects an existing filter.
@@ -208,7 +220,11 @@ module Sequel
     def group(*columns)
       clone(:group => (columns.compact.empty? ? nil : columns))
     end
-    alias group_by group
+
+    # Alias of group
+    def group_by(*columns)
+      group(*columns)
+    end
     
     # Returns a dataset grouped by the given column with count by group,
     # order by the count of records. Column aliases may be supplied, and will
@@ -260,6 +276,11 @@ module Sequel
       clone(o)
     end
 
+    # Alias of inner_join
+    def join(*args, &block)
+      inner_join(*args, &block)
+    end
+
     # Returns a joined dataset.  Uses the following arguments:
     #
     # * type - The type of join to do (e.g. :inner)
@@ -352,7 +373,6 @@ module Sequel
     UNCONDITIONED_JOIN_TYPES.each do |jtype|
       class_eval("def #{jtype}_join(table); raise(Sequel::Error, '#{jtype}_join does not accept join table blocks') if block_given?; join_table(:#{jtype}, table) end", __FILE__, __LINE__)
     end
-    alias join inner_join
 
     # If given an integer, the dataset will contain only the first l results.
     # If given a range, it will contain only those at offsets within that
@@ -426,10 +446,19 @@ module Sequel
       columns += Array(Sequel.virtual_row(&block)) if block
       clone(:order => (columns.compact.empty?) ? nil : columns)
     end
-    alias order_by order
     
+    # Alias of order_more, for naming consistency with order_prepend.
+    def order_append(*columns, &block)
+      order_more(*columns, &block)
+    end
+
+    # Alias of order
+    def order_by(*columns, &block)
+      order(*columns, &block)
+    end
+
     # Returns a copy of the dataset with the order columns added
-    # to the existing order.
+    # to the end of the existing order.
     #
     #   ds.order(:a).order(:b).sql #=> 'SELECT * FROM items ORDER BY b'
     #   ds.order(:a).order_more(:b).sql #=> 'SELECT * FROM items ORDER BY a, b'
@@ -438,6 +467,16 @@ module Sequel
       order(*columns, &block)
     end
     
+    # Returns a copy of the dataset with the order columns added
+    # to the beginning of the existing order.
+    #
+    #   ds.order(:a).order(:b).sql #=> 'SELECT * FROM items ORDER BY b'
+    #   ds.order(:a).order_prepend(:b).sql #=> 'SELECT * FROM items ORDER BY b, a'
+    def order_prepend(*columns, &block)
+      ds = order(*columns, &block)
+      @opts[:order] ? ds.order_more(*@opts[:order]) : ds
+    end
+    
     # Qualify to the given table, or first source if not table is given.
     def qualify(table=first_source)
       qualify_to(table)
@@ -469,10 +508,14 @@ module Sequel
     
     # Returns a copy of the dataset with the order reversed. If no order is
     # given, the existing order is inverted.
-    def reverse_order(*order)
+    def reverse(*order)
       order(*invert_order(order.empty? ? @opts[:order] : order))
     end
-    alias reverse reverse_order
+
+    # Alias of reverse
+    def reverse_order(*order)
+      reverse(*order)
+    end
 
     # Returns a copy of the dataset with the columns selected changed
     # to the given columns. This also takes a virtual row block,

data/lib/sequel/exceptions.rb

@@ -32,6 +32,9 @@ module Sequel
   # Raised when attempting an invalid type conversion.
   class InvalidValue < Error ; end
 
+  # Raised when the adapter adapter hasn't implemented a method such as +tables+:
+  class NotImplemented < Error; end
+
   # Raised when the connection pool cannot acquire a database connection
   # before the timeout.
   class PoolTimeout < Error ; end

data/lib/sequel/extensions/migration.rb

@@ -3,51 +3,23 @@
 # to a newer version or revert to a previous version.
 
 module Sequel
-  # The Migration class describes a database migration that can be reversed.
-  # The migration looks very similar to ActiveRecord (Rails) migrations, e.g.:
-  #
-  #   class CreateSessions < Sequel::Migration
-  #     def up
-  #       create_table :sessions do
-  #         primary_key :id
-  #         String :session_id, :size => 32, :unique => true
-  #         DateTime :created_at
-  #         text :data
-  #       end
-  #     end
+  # Sequel's older migration class, available for backward compatibility.
+  # Uses subclasses with up and down instance methods for each migration:
   # 
-  #     def down
-  #       # You can use raw SQL if you need to
-  #       self << 'DROP TABLE sessions'
-  #     end
-  #   end
-  #
-  #   class AlterItems < Sequel::Migration
+  #   Class.new(Sequel::Migration) do
   #     def up
-  #       alter_table :items do
-  #         add_column :category, String, :default => 'ruby'
+  #       create_table(:artists) do
+  #         primary_key :id
+  #         String :name
   #       end
   #     end
-  # 
+  #     
   #     def down
-  #       alter_table :items do
-  #         drop_column :category
-  #       end  
+  #       drop_table(:artists)
   #     end
   #   end
   #
-  # To apply a migration to a database, you can invoke the #apply with
-  # the target database instance and the direction :up or :down, e.g.:
-  #
-  #   DB = Sequel.connect('sqlite://mydb')
-  #   CreateSessions.apply(DB, :up)
-  #
-  # See Sequel::Schema::Generator for the syntax to use for creating tables,
-  # and Sequel::Schema::AlterTableGenerator for the syntax to use when
-  # altering existing tables.  Migrations act as a proxy for the database
-  # given in #apply, so inside #down and #up, you can act as though self
-  # refers to the database.  So you can use any of the Sequel::Database
-  # instance methods directly.
+  # Part of the +migration+ extension.
   class Migration
     # Creates a new instance of the migration and sets the @db attribute.
     def initialize(db)
@@ -57,15 +29,8 @@ module Sequel
     # Applies the migration to the supplied database in the specified
     # direction.
     def self.apply(db, direction)
-      obj = new(db)
-      case direction
-      when :up
-        obj.up
-      when :down
-        obj.down
-      else
-        raise ArgumentError, "Invalid migration direction specified (#{direction.inspect})"
-      end
+      raise(ArgumentError, "Invalid migration direction specified (#{direction.inspect})") unless [:up, :down].include?(direction)
+      new(db).send(direction)
     end
 
     # Returns the list of Migration descendants.
@@ -92,9 +57,77 @@ module Sequel
     end
   end
 
-  # The Migrator module performs migrations based on migration files in a 
+  # Migration class used by the Sequel.migration DSL,
+  # using instances for each migration, unlike the
+  # +Migration+ class, which uses subclasses for each
+  # migration. Part of the +migration+ extension.
+  class SimpleMigration
+    # Proc used for the down action
+    attr_accessor :down
+
+    # Proc used for the up action
+    attr_accessor :up
+
+    # Apply the appropriate block on the +Database+
+    # instance using instance_eval.
+    def apply(db, direction)
+      raise(ArgumentError, "Invalid migration direction specified (#{direction.inspect})") unless [:up, :down].include?(direction)
+      if prok = send(direction)
+        db.instance_eval(&prok)
+      end
+    end
+  end
+
+  # Internal class used by the Sequel.migration DSL, part of the +migration+ extension.
+  class MigrationDSL < BasicObject
+    # The underlying Migration class.
+    attr_reader :migration
+
+    def self.create(&block)
+      new(&block).migration
+    end
+
+    # Create a new migration class, and instance_eval the block.
+    def initialize(&block)
+      @migration = SimpleMigration.new
+      Migration.descendants << migration
+      instance_eval(&block)
+    end
+
+    # Defines the migration's down action.
+    def down(&block)
+      migration.down = block
+    end
+
+    # Defines the migration's up action.
+    def up(&block)
+      migration.up = block
+    end
+  end
+
+  # The preferred method for writing Sequel migrations, using a DSL:
+  # 
+  #   Sequel.migration do
+  #     up do
+  #       create_table(:artists) do
+  #         primary_key :id
+  #         String :name
+  #       end
+  #     end
+  #     
+  #     down do
+  #       drop_table(:artists)
+  #     end
+  #   end
+  #
+  # Designed to be used with the +Migrator+ class, part of the +migration+ extension.
+  def self.migration(&block)
+    MigrationDSL.create(&block)
+  end
+
+  # The +Migrator+ class performs migrations based on migration files in a 
   # specified directory. The migration files should be named using the
-  # following pattern (in similar fashion to ActiveRecord migrations):
+  # following pattern:
   # 
   #   <version>_<title>.rb
   #
@@ -102,10 +135,21 @@ module Sequel
   #   
   #   001_create_sessions.rb
   #   002_add_data_column.rb
-  #   ...
+  #   
+  # You can also use timestamps as version numbers:
+  #
+  #   1273253850_create_sessions.rb
+  #   1273257248_add_data_column.rb
   #
-  # The migration files should contain one or more migration classes based
-  # on Sequel::Migration.
+  # If any migration filenames use timestamps as version numbers, Sequel
+  # uses the +TimestampMigrator+ to migrate, otherwise it uses the +IntegerMigrator+.
+  # The +TimestampMigrator+ can handle migrations that are run out of order
+  # as well as migrations with the same timestamp,
+  # while the +IntegerMigrator+ is more strict and raises exceptions for missing
+  # or duplicate migration files.
+  #
+  # The migration files should contain either one +Migration+
+  # subclass or one <tt>Sequel.migration</tt> call.
   #
   # Migrations are generally run via the sequel command line tool,
   # using the -m and -M switches.  The -m switch specifies the migration
@@ -114,10 +158,11 @@ module Sequel
   # You can apply migrations using the Migrator API, as well (this is necessary
   # if you want to specify the version from which to migrate in addition to the version
   # to which to migrate).
-  # To apply a migration, the #apply method must be invoked with the database
+  # To apply a migrator, the +apply+ method must be invoked with the database
   # instance, the directory of migration files and the target version. If
   # no current version is supplied, it is read from the database. The migrator
-  # automatically creates a schema_info table in the database to keep track
+  # automatically creates a table (schema_info for integer migrations and
+  # schema_migrations for timestamped migrations). in the database to keep track
   # of the current migration version. If no migration version is stored in the
   # database, the version is considered to be 0. If no target version is 
   # specified, the database is migrated to the latest version available in the
@@ -127,26 +172,40 @@ module Sequel
   #
   #   Sequel::Migrator.apply(DB, '.')
   #
+  # For example, to migrate the database all the way down:
+  #
+  #   Sequel::Migrator.apply(DB, '.', 0)
+  #
+  # For example, to migrate the database to version 4:
+  #
+  #   Sequel::Migrator.apply(DB, '.', 4)
+  #
   # To migrate the database from version 1 to version 5:
   #
   #   Sequel::Migrator.apply(DB, '.', 5, 1)
-  module Migrator
-    DEFAULT_SCHEMA_COLUMN = :version
-    DEFAULT_SCHEMA_TABLE = :schema_info
-    MIGRATION_FILE_PATTERN = /\A\d+_.+\.rb\z/.freeze
+  #
+  # Part of the +migration+ extension.
+  class Migrator
+    MIGRATION_FILE_PATTERN = /\A\d+_.+\.rb\z/i.freeze
     MIGRATION_SPLITTER = '_'.freeze
+    MINIMUM_TIMESTAMP = 20000101
 
-    # Wrapper for run, maintaining backwards API compatibility
+    # Exception class raised when there is an error with the migrator's
+    # file structure, database, or arguments.
+    class Error < Sequel::Error
+    end
+
+    # Wrapper for +run+, maintaining backwards API compatibility
     def self.apply(db, directory, target = nil, current = nil)
       run(db, directory, :target => target, :current => current)
     end
 
     # Migrates the supplied database using the migration files in the the specified directory. Options:
-    # * :column - The column in the :table argument storing the migration version (default: :version).
-    # * :current - The current version of the database.  If not given, it is retrieved from the database
-    #   using the :table and :column options.
-    # * :table - The table containing the schema version (default: :schema_info).
-    # * :target - The target version to which to migrate.  If not given, migrates to the maximum version.
+    # * :column :: The column in the :table argument storing the migration version (default: :version).
+    # * :current :: The current version of the database.  If not given, it is retrieved from the database
+    #               using the :table and :column options.
+    # * :table :: The table containing the schema version (default: :schema_info).
+    # * :target :: The target version to which to migrate.  If not given, migrates to the maximum version.
     #
     # Examples: 
     #   Sequel::Migrator.run(DB, "migrations")
@@ -154,86 +213,309 @@ module Sequel
     #   Sequel::Migrator.run(DB, "app1/migrations", :column=> :app2_version)
     #   Sequel::Migrator.run(DB, "app2/migrations", :column => :app2_version, :table=>:schema_info2)
     def self.run(db, directory, opts={})
-      raise(Error, "Must supply a valid migration path") unless directory and File.directory?(directory)
-      raise(Error, "No current version available") unless current = opts[:current] || get_current_migration_version(db, opts)
-      raise(Error, "No target version available") unless target  = opts[:target]  || latest_migration_version(directory)
+      migrator_class(directory).new(db, directory, opts).run
+    end
 
-      direction = current < target ? :up : :down
-      
-      classes = migration_classes(directory, target, current, direction)
+    # Choose the Migrator subclass to use.  Uses the TimestampMigrator
+    # if the version number appears to be a unix time integer for a year
+    # after 2005, otherwise uses the IntegerMigrator.
+    def self.migrator_class(directory)
+      Dir.new(directory).each do |file|
+        next unless MIGRATION_FILE_PATTERN.match(file)
+        return TimestampMigrator if file.split(MIGRATION_SPLITTER, 2).first.to_i > MINIMUM_TIMESTAMP
+      end
+      IntegerMigrator
+    end
+    private_class_method :migrator_class
+    
+    # The column to use to hold the migration version number for integer migrations or
+    # filename for timestamp migrations (defaults to :version for integer migrations and
+    # :filename for timestamp migrations)
+    attr_reader :column
+
+    # The database related to this migrator
+    attr_reader :db
+
+    # The directory for this migrator's files
+    attr_reader :directory
+
+    # The dataset for this migrator, representing the +schema_info+ table for integer
+    # migrations and the +schema_migrations+ table for timestamp migrations
+    attr_reader :ds
+
+    # All migration files in this migrator's directory
+    attr_reader :files
+
+    # The table to use to hold the applied migration data (defaults to :schema_info for
+    # integer migrations and :schema_migrations for timestamp migrations)
+    attr_reader :table
+
+    # The target version for this migrator
+    attr_reader :target
 
-      db.transaction do
-        classes.each {|c| c.apply(db, direction)}
-        set_current_migration_version(db, target, opts)
+    # Setup the state for the migrator
+    def initialize(db, directory, opts={})
+      raise(Error, "Must supply a valid migration path") unless File.directory?(directory)
+      @db = db
+      @directory = directory
+      @files = get_migration_files
+      @table = opts[:table]  || self.class.const_get(:DEFAULT_SCHEMA_TABLE)
+      @column = opts[:column] || self.class.const_get(:DEFAULT_SCHEMA_COLUMN)
+      @ds = schema_dataset
+    end
+
+    private
+
+    # Remove all migration classes.  Done by the migrator to ensure that
+    # the correct migration classes are picked up.
+    def remove_migration_classes
+      # Remove class definitions
+      Migration.descendants.each do |c|
+        Object.send(:remove_const, c.to_s) rescue nil
+      end
+      Migration.descendants.clear # remove any defined migration classes
+    end
+
+    # Return the integer migration version based on the filename.
+    def migration_version_from_file(filename)
+      filename.split(MIGRATION_SPLITTER, 2).first.to_i
+    end
+  end
+
+  # The default migrator, recommended in most cases.  Uses a simple incrementing
+  # version number starting with 1, where missing or duplicate migration file
+  # versions are not allowed.  Part of the +migration+ extension.
+  class IntegerMigrator < Migrator
+    DEFAULT_SCHEMA_COLUMN = :version
+    DEFAULT_SCHEMA_TABLE = :schema_info
+
+    Error = Migrator::Error
+
+    # The current version for this migrator
+    attr_reader :current
+
+    # The direction of the migrator, either :up or :down
+    attr_reader :direction
+
+    # The migrations used by this migrator
+    attr_reader :migrations
+
+    # Set up all state for the migrator instance
+    def initialize(db, directory, opts={})
+      super
+      @target = opts[:target] || latest_migration_version
+      @current = opts[:current] || current_migration_version
+      @direction = current < target ? :up : :down
+      @migrations = get_migrations
+
+      raise(Error, "No current version available") unless current
+      raise(Error, "No target version available") unless target
+    end
+
+    # Apply all migrations on the database
+    def run
+      migrations.zip(version_numbers).each do |m, v|
+        t = Time.now
+        lv = up? ? v : v + 1
+        db.log_info("Begin applying migration version #{lv}, direction: #{direction}")
+        db.transaction do
+          m.apply(db, direction)
+          set_migration_version(v)
+        end
+        db.log_info("Finished applying migration version #{lv}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
       end
       
       target
     end
 
+    private
+
     # Gets the current migration version stored in the database. If no version
     # number is stored, 0 is returned.
-    def self.get_current_migration_version(db, opts={})
-      (schema_info_dataset(db, opts).first || {})[opts[:column] || DEFAULT_SCHEMA_COLUMN] || 0
+    def current_migration_version
+      ds.get(column) || 0
     end
 
-    # Returns the latest version available in the specified directory.
-    def self.latest_migration_version(directory)
-      l = migration_files(directory).last
-      l ? migration_version_from_file(File.basename(l)) : nil
+    # Returns any found migration files in the supplied directory.
+    def get_migration_files
+      files = []
+      Dir.new(directory).each do |file|
+        next unless MIGRATION_FILE_PATTERN.match(file)
+        version = migration_version_from_file(file)
+        raise(Error, "Duplicate migration version: #{version}") if files[version]
+        files[version] = File.join(directory, file)
+      end
+      1.upto(files.length - 1){|i| raise(Error, "Missing migration version: #{i}") unless files[i]}
+      files
     end
-
+    
     # Returns a list of migration classes filtered for the migration range and
     # ordered according to the migration direction.
-    def self.migration_classes(directory, target, current, direction)
-      range = direction == :up ?
-        (current + 1)..target : (target + 1)..current
-
-      # Remove class definitions
-      Migration.descendants.each do |c|
-        Object.send(:remove_const, c.to_s) rescue nil
-      end
-      Migration.descendants.clear # remove any defined migration classes
+    def get_migrations
+      remove_migration_classes
 
       # load migration files
-      migration_files(directory, range).each {|fn| load(fn)}
+      files[up? ? (current + 1)..target : (target + 1)..current].compact.each{|f| load(f)}
       
       # get migration classes
       classes = Migration.descendants
-      classes.reverse! if direction == :down
-      classes
+      up? ? classes : classes.reverse
     end
     
-    # Returns any found migration files in the supplied directory.
-    def self.migration_files(directory, range = nil)
-      files = []
-      Dir.new(directory).each do |file|
-        files[migration_version_from_file(file)] = File.join(directory, file) if MIGRATION_FILE_PATTERN.match(file)
-      end
-      filtered = range ? files[range] : files
-      filtered ? filtered.compact : []
+    # Returns the latest version available in the specified directory.
+    def latest_migration_version
+      l = files.last
+      l ? migration_version_from_file(File.basename(l)) : nil
     end
     
     # Returns the dataset for the schema_info table. If no such table
     # exists, it is automatically created.
-    def self.schema_info_dataset(db, opts={})
-      column = opts[:column] || DEFAULT_SCHEMA_COLUMN
-      table  = opts[:table]  || DEFAULT_SCHEMA_TABLE
-      db.create_table?(table){Integer column}
-      db.alter_table(table){add_column column, Integer} unless db.from(table).columns.include?(column)
-      db.from(table)
+    def schema_dataset
+      c = column
+      ds = db.from(table)
+      if !db.table_exists?(table)
+        db.create_table(table){Integer c, :default=>0, :null=>false}
+      elsif !ds.columns.include?(c)
+        db.alter_table(table){add_column c, Integer, :default=>0, :null=>false}
+      end
+      ds.insert(c=>0) if ds.empty?
+      raise(Error, "More than 1 row in migrator table") if ds.count > 1
+      ds
     end
     
     # Sets the current migration  version stored in the database.
-    def self.set_current_migration_version(db, version, opts={})
-      column = opts[:column] || DEFAULT_SCHEMA_COLUMN
-      dataset = schema_info_dataset(db, opts)
-      dataset.send(dataset.first ? :update : :insert, column => version)
+    def set_migration_version(version)
+      ds.update(column=>version)
     end
 
-    # Return the integer migration version based on the filename.
-    def self.migration_version_from_file(filename) # :nodoc:
-      filename.split(MIGRATION_SPLITTER, 2).first.to_i
+    # Whether or not this is an up migration
+    def up?
+      direction == :up
+    end
+
+    # An array of numbers corresponding to the migrations,
+    # so that each number in the array is the migration version
+    # that will be in affect after the migration is run.
+    def version_numbers
+      up? ? ((current+1)..target).to_a : (target..(current - 1)).to_a.reverse
+    end
+  end
+
+  # The migrator used if any migration file version appears to be a timestamp.
+  # Stores filenames of migration files, and can figure out which migrations
+  # have not been applied and apply them, even if earlier migrations are added
+  # after later migrations.  If you plan to do that, the responsibility is on
+  # you to make sure the migrations don't conflict. Part of the +migration+ extension.
+  class TimestampMigrator < Migrator
+    DEFAULT_SCHEMA_COLUMN = :filename
+    DEFAULT_SCHEMA_TABLE = :schema_migrations
+    
+    Error = Migrator::Error
+
+    # Array of strings of applied migration filenames
+    attr_reader :applied_migrations
+
+    # Get tuples of migrations, filenames, and actions for each migration
+    attr_reader :migration_tuples
+
+    # Set up all state for the migrator instance
+    def initialize(db, directory, opts={})
+      super
+      @target = opts[:target]
+      @applied_migrations = get_applied_migrations
+      @migration_tuples = get_migration_tuples
+    end
+
+    # Apply all migration tuples on the database
+    def run
+      migration_tuples.each do |m, f, direction|
+        t = Time.now
+        db.log_info("Begin applying migration #{f}, direction: #{direction}")
+        db.transaction do
+          m.apply(db, direction)
+          fi = f.downcase
+          direction == :up ? ds.insert(column=>fi) : ds.filter(column=>fi).delete
+        end
+        db.log_info("Finished applying migration #{f}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+      end
+      nil
+    end
+
+    private
+
+    # Convert the schema_info table to the new schema_migrations table format,
+    # using the version of the schema_info table and the current migration files.
+    def convert_from_schema_info
+      v = db[IntegerMigrator::DEFAULT_SCHEMA_TABLE].get(IntegerMigrator::DEFAULT_SCHEMA_COLUMN)
+      ds = db.from(table)
+      files.each do |path|
+        f = File.basename(path)
+        if migration_version_from_file(f) <= v
+          ds.insert(column=>f)
+        end
+      end
+    end
+
+    # Returns filenames of all applied migrations
+    def get_applied_migrations
+      am = ds.select_order_map(column)
+      missing_migration_files = am - files.map{|f| File.basename(f).downcase}
+      raise(Error, "Applied migration files not in file system: #{missing_migration_files.join(', ')}") if missing_migration_files.length > 0
+      am
+    end
+    
+    # Returns any migration files found in the migrator's directory.
+    def get_migration_files
+      files = []
+      Dir.new(directory).each do |file|
+        next unless MIGRATION_FILE_PATTERN.match(file)
+        files << File.join(directory, file)
+      end
+      files.sort
+    end
+    
+    # Returns tuples of migration, filename, and direction
+    def get_migration_tuples
+      remove_migration_classes
+      up_mts = []
+      down_mts = []
+      ms = Migration.descendants
+      files.each do |path|
+        f = File.basename(path)
+        fi = f.downcase
+        if target
+          if migration_version_from_file(f) > target
+            if applied_migrations.include?(fi)
+              load(path)
+              down_mts << [ms.last, f, :down]
+            end
+          elsif !applied_migrations.include?(fi)
+            load(path)
+            up_mts << [ms.last, f, :up]
+          end
+        elsif !applied_migrations.include?(fi)
+          load(path)
+          up_mts << [ms.last, f, :up]
+        end
+      end
+      up_mts + down_mts.reverse
+    end
+    
+    # Returns the dataset for the schema_migrations table. If no such table
+    # exists, it is automatically created.
+    def schema_dataset
+      c = column
+      ds = db.from(table)
+      if !db.table_exists?(table)
+        db.create_table(table){String c, :primary_key=>true}
+        if db.table_exists?(:schema_info) and vha = db[:schema_info].all and vha.length == 1 and
+           vha.first.keys == [:version] and vha.first.values.first.is_a?(Integer)
+          convert_from_schema_info
+        end
+      elsif !ds.columns.include?(c)
+        raise(Error, "Migrator table #{table} does not contain column #{c}")
+      end
+      ds
     end
-    private_class_method :migration_version_from_file
   end
 end