sequel 5.45.0 → 5.77.0

data/lib/sequel/extensions/connection_validator.rb

@@ -28,22 +28,22 @@
 # connections on every checkout without setting up coarse
 # connection checkouts will hurt performance, in some cases
 # significantly.  Note that setting up coarse connection
-# checkouts reduces the concurrency level acheivable.  For
+# checkouts reduces the concurrency level achievable.  For
 # example, in a web application, using Database#synchronize
 # in a rack middleware will limit the number of concurrent
 # web requests to the number to connections in the database
 # connection pool.
 #
-# Note that this extension only affects the default threaded
-# and the sharded threaded connection pool.  The single
-# threaded and sharded single threaded connection pools are
-# not affected.  As the only reason to use the single threaded
+# Note that this extension does not work with the single
+# threaded and sharded single threaded connection pools.
+# As the only reason to use the single threaded
 # pools is for speed, and this extension makes the connection
 # pool slower, there's not much point in modifying this
 # extension to work with the single threaded pools.  The
-# threaded pools work fine even in single threaded code, so if
-# you are currently using a single threaded pool and want to
-# use this extension, switch to using a threaded pool.
+# non-single threaded pools work fine even in single threaded
+# code, so if you are currently using a single threaded pool
+# and want to use this extension, switch to using another
+# pool.
 #
 # Related module: Sequel::ConnectionValidator
 
@@ -61,6 +61,11 @@ module Sequel
 
     # Initialize the data structures used by this extension.
     def self.extended(pool)
+      case pool.pool_type
+      when :single, :sharded_single
+        raise Error, "cannot load connection_validator extension if using single or sharded_single connection pool"
+      end
+
       pool.instance_exec do
         sync do
           @connection_timestamps ||= {}
@@ -103,8 +108,9 @@ module Sequel
            Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
            !db.valid_connection?(conn)
 
-          if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Sequel.current)}
+          case pool_type
+          when :sharded_threaded, :sharded_timed_queue
+            sync{@allocated[a.last].delete(Sequel.current)}
           else
             sync{@allocated.delete(Sequel.current)}
           end
@@ -120,4 +126,3 @@ module Sequel
 
   Database.register_extension(:connection_validator){|db| db.pool.extend(ConnectionValidator)}
 end
-

data/lib/sequel/extensions/constraint_validations.rb

@@ -126,7 +126,7 @@
 #   be emulated by dropping the table and recreating it with the constraints.
 #   If you want to use this plugin on SQLite with an alter_table block,
 #   you should drop all constraint validation metadata using
-#   <tt>drop_constraint_validations_for(:table=>'table')</tt>, and then
+#   <tt>drop_constraint_validations_for(table: 'table')</tt>, and then
 #   readd all constraints you want to use inside the alter table block,
 #   making no other changes inside the alter_table block.
 #

data/lib/sequel/extensions/core_refinements.rb

@@ -15,6 +15,12 @@ raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VE
 # :nocov:
 
 module Sequel::CoreRefinements
+  # :nocov:
+  include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
+  # :nocov:
+  INCLUDE_METH = include_meth
+  private_constant :INCLUDE_METH
+
   refine Array do
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
     # conditions.
@@ -161,8 +167,8 @@ module Sequel::CoreRefinements
   end
 
   refine String do
-    include Sequel::SQL::AliasMethods
-    include Sequel::SQL::CastMethods
+    send include_meth, Sequel::SQL::AliasMethods
+    send include_meth, Sequel::SQL::CastMethods
 
     # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
     # literalization, e.g.:
@@ -189,15 +195,34 @@ module Sequel::CoreRefinements
   end
 
   refine Symbol do
-    include Sequel::SQL::AliasMethods
-    include Sequel::SQL::CastMethods
-    include Sequel::SQL::OrderMethods
-    include Sequel::SQL::BooleanMethods
-    include Sequel::SQL::NumericMethods
-    include Sequel::SQL::QualifyingMethods
-    include Sequel::SQL::StringMethods
-    include Sequel::SQL::SubscriptMethods
-    include Sequel::SQL::ComplexExpressionMethods
+    send include_meth, Sequel::SQL::AliasMethods
+    send include_meth, Sequel::SQL::CastMethods
+    send include_meth, Sequel::SQL::OrderMethods
+    send include_meth, Sequel::SQL::BooleanMethods
+    send include_meth, Sequel::SQL::NumericMethods
+
+    # :nocov:
+    remove_method :* if RUBY_VERSION >= '3.1'
+    # :nocov:
+
+    send include_meth, Sequel::SQL::QualifyingMethods
+    send include_meth, Sequel::SQL::StringMethods
+    send include_meth, Sequel::SQL::SubscriptMethods
+    send include_meth, Sequel::SQL::ComplexExpressionMethods
+
+    # :nocov:
+    if RUBY_VERSION >= '3.1'
+      remove_method :*
+      def *(ce=(arg=false;nil))
+        if arg == false
+          Sequel::SQL::ColumnAll.new(self)
+        else
+          Sequel::SQL::NumericExpression.new(:*, self, ce)
+        end
+      end
+
+    end
+    # :nocov:
 
     # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.
     #

data/lib/sequel/extensions/date_arithmetic.rb

@@ -25,13 +25,17 @@
 # By default, values are casted to the generic timestamp type for the
 # database.  You can override the cast type using the :cast option:
 #
-#   add = Sequel.date_add(:date_column, {years: 1, months: 2, days: 3}, :cast=>:timestamptz)
+#   add = Sequel.date_add(:date_column, {years: 1, months: 2, days: 3}, cast: :timestamptz)
 #
 # These expressions can be used in your datasets, or anywhere else that
 # Sequel expressions are allowed:
 #
 #   DB[:table].select(add.as(:d)).where(sub > Sequel::CURRENT_TIMESTAMP)
 #
+# On most databases, the values you provide for years/months/days/etc. must
+# be numeric values and not arbitrary SQL expressions.  However, on PostgreSQL
+# 9.4+, use of arbitrary SQL expressions is supported.
+#
 # Related module: Sequel::SQL::DateAdd
 
 #
@@ -54,7 +58,16 @@ module Sequel
           interval = interval.parts
         end
         parts = {}
-        interval.each{|k,v| parts[k] = -v unless v.nil?}
+        interval.each do |k,v|
+          case v
+          when nil
+            # ignore
+          when Numeric
+            parts[k] = -v
+          else
+            parts[k] = Sequel::SQL::NumericExpression.new(:*, v, -1)
+          end
+        end
         DateAdd.new(expr, parts, opts)
       end
     end
@@ -68,6 +81,7 @@ module Sequel
       module DatasetMethods
         DURATION_UNITS = [:years, :months, :days, :hours, :minutes, :seconds].freeze
         DEF_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s.freeze}).freeze
+        POSTGRES_DURATION_UNITS = DURATION_UNITS.zip([:years, :months, :days, :hours, :mins, :secs].map{|s| s.to_s.freeze}).freeze
         MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1]).freeze}).freeze
         MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
         H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
@@ -87,14 +101,28 @@ module Sequel
 
           cast = case db_type = db.database_type
           when :postgres
-            interval = String.new
-            each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
-              interval << "#{value} #{sql_unit} "
+            casted = Sequel.cast(expr, cast_type)
+
+            if db.server_version >= 90400
+              placeholder = []
+              vals = []
+              each_valid_interval_unit(h, POSTGRES_DURATION_UNITS) do |value, sql_unit|
+                placeholder << "#{', ' unless placeholder.empty?}#{sql_unit} := "
+                vals << value
+              end
+              interval = Sequel.function(:make_interval, Sequel.lit(placeholder, *vals)) unless vals.empty?
+            else
+              parts = String.new
+              each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+                parts << "#{value} #{sql_unit} "
+              end
+              interval = Sequel.cast(parts, :interval) unless parts.empty?
             end
-            if interval.empty?
-              return literal_append(sql, Sequel.cast(expr, cast_type))
+
+            if interval
+              return complex_expression_sql_append(sql, :+, [casted, interval])
             else
-              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, cast_type), Sequel.cast(interval, :interval)])
+              return literal_append(sql, casted)
             end
           when :sqlite
             args = [expr]

data/lib/sequel/extensions/date_parse_input_handler.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+#
+# The date_parse_input_handler extension allows for configuring how input
+# to date parsing methods should be handled.  By default, the
+# extension does not change behavior.  However, you can use the
+# +Sequel.date_parse_input_handler+ method to support custom handling
+# of input strings to the date parsing methods.  For example, if you want
+# to implement a length check to prevent denial of service vulnerabilities
+# in older versions of Ruby, you can do:
+#
+#   Sequel.extension :date_parse_input_handler
+#   Sequel.date_parse_input_handler do |string|
+#     raise Sequel::InvalidValue, "string length (200) exceeds the limit 128" if string.bytesize > 128
+#     string
+#   end
+#
+# You can also use +Sequel.date_parse_input_handler+ to modify the string
+# that will be passed to the parsing methods.  For example, you could
+# truncate it:
+#
+#   Sequel.date_parse_input_handler do |string|
+#     string.b[0, 128]
+#   end
+#
+# Be aware that modern versions of Ruby will raise an exception if
+# date parsing input exceeds 128 bytes.
+
+module Sequel
+  module DateParseInputHandler
+    def date_parse_input_handler(&block)
+      singleton_class.class_eval do
+        define_method(:handle_date_parse_input, &block)
+        private :handle_date_parse_input
+        alias handle_date_parse_input handle_date_parse_input
+      end
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_date(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_datetime(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_time(string)
+      super(handle_date_parse_input(string))
+    end
+
+    private
+
+    # Call date parse input handler with input string.
+    def _date_parse(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Return string as-is by default, so by default behavior does not change.
+    def handle_date_parse_input(string)
+      string
+    end
+  end
+
+  extend DateParseInputHandler
+end

data/lib/sequel/extensions/datetime_parse_to_time.rb

@@ -19,7 +19,11 @@ module Sequel::DateTimeParseToTime
   # Use DateTime.parse.to_time to do the conversion if the input a string and is assumed to
   # be in UTC and there is no offset information in the string.
   def convert_input_timestamp(v, input_timezone)
-    if v.is_a?(String) && datetime_class == Time && input_timezone == :utc && !Date._parse(v).has_key?(:offset)
+    if v.is_a?(String) && datetime_class == Time && input_timezone == :utc && !_date_parse(v).has_key?(:offset)
+      # :nocov:
+      # Whether this is fully branch covered depends on the order in which the specs are run.
+      v = handle_date_parse_input(v) if respond_to?(:handle_date_parse_input, true)
+      # :nocov:
       t = DateTime.parse(v).to_time
       case application_timezone
       when nil, :local

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -14,12 +14,12 @@
 #
 #   ds = DB[:items].extension(:duplicate_columns_handler)
 #
-# A database option is introduced: :on_duplicate_columns. It accepts a Symbol
-# or any object that responds to :call.
+# If the Database option :on_duplicate_columns is set, it configures how this
+# extension works. The value should be # or any object that responds to :call.
 #
-#   on_duplicate_columns: :raise
-#   on_duplicate_columns: :warn
-#   on_duplicate_columns: :ignore
+#   on_duplicate_columns: :raise # or 'raise'
+#   on_duplicate_columns: :warn # or 'warn'
+#   on_duplicate_columns: :ignore # or anything unrecognized
 #   on_duplicate_columns: lambda{|columns| arbitrary_condition? ? :raise : :warn}
 #
 # You may also configure duplicate columns handling for a specific dataset:
@@ -30,9 +30,10 @@
 #   ds.on_duplicate_columns{|columns| arbitrary_condition? ? :raise : :warn}
 #   ds.on_duplicate_columns(lambda{|columns| arbitrary_condition? ? :raise : :warn})
 #
-# If :raise is specified, a Sequel::DuplicateColumnError is raised.
-# If :warn is specified, you will receive a warning via +warn+.
+# If :raise or 'raise' is specified, a Sequel::DuplicateColumnError is raised.
+# If :warn or 'warn' is specified, you will receive a warning via +warn+.
 # If a callable is specified, it will be called.
+# For other values, duplicate columns are ignored (Sequel's default behavior)
 # If no on_duplicate_columns is specified, the default is :warn.
 #
 # Related module: Sequel::DuplicateColumnsHandler
@@ -44,7 +45,7 @@ module Sequel
     # :nocov:
 
     # Customize handling of duplicate columns for this dataset.
-    def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless block_given?; nil), &block)
+    def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless defined?(yield); nil), &block)
       raise Error, "Cannot provide both an argument and a block to on_duplicate_columns" if handler && block
       clone(:on_duplicate_columns=>handler||block)
     end
@@ -64,9 +65,9 @@ module Sequel
       message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"
 
       case duplicate_columns_handler_type(cols)
-      when :raise
+      when :raise, 'raise'
         raise DuplicateColumnError, message
-      when :warn
+      when :warn, 'warn'
         warn message
       end
     end

data/lib/sequel/extensions/index_caching.rb

@@ -56,7 +56,11 @@ module Sequel
     
     # Dump the index cache to the filename given in Marshal format.
     def dump_index_cache(file)
-      File.open(file, 'wb'){|f| f.write(Marshal.dump(@indexes))}
+      indexes = {}
+      @indexes.sort.each do |k, v|
+        indexes[k] = v
+      end
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(indexes))}
       nil
     end
 

data/lib/sequel/extensions/inflector.rb

@@ -102,7 +102,7 @@ class String
   # Yield the Inflections module if a block is given, and return
   # the Inflections module.
   def self.inflections
-    yield Inflections if block_given?
+    yield Inflections if defined?(yield)
     Inflections
   end
   

data/lib/sequel/extensions/is_distinct_from.rb

@@ -0,0 +1,141 @@
+# frozen-string-literal: true
+#
+# The is_distinct_from extension adds the ability to use the
+# SQL standard IS DISTINCT FROM operator, which is similar to the
+# not equals operator, except that NULL values are considered
+# equal.  PostgreSQL, SQLite 3.39+, and H2 currently support this operator.  On 
+# other databases, support is emulated.
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :is_distinct_from
+#
+# Then you can use the Sequel.is_distinct_from to create the expression
+# objects:  
+#
+#   expr = Sequel.is_distinct_from(:column_a, :column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#
+# You can also use the +is_distinct_from+ method on most Sequel expressions:
+#
+#   expr = Sequel[:column_a].is_distinct_from(:column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#   
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].where(expr)
+#
+# Related module: Sequel::SQL::IsDistinctFrom
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a IsDistinctFrom expression object, using the IS DISTINCT FROM operator
+      # with the given left hand side and right hand side.
+      def is_distinct_from(lhs, rhs)
+        BooleanExpression.new(:NOOP, IsDistinctFrom.new(lhs, rhs))
+      end
+    end
+
+    # Represents an SQL expression using the IS DISTINCT FROM operator.
+    class IsDistinctFrom < GenericExpression
+      # These methods are added to expressions, allowing them to return IS DISTINCT
+      # FROM expressions based on the receiving expression.
+      module Methods
+        # Return a IsDistinctFrom expression, using the IS DISTINCT FROM operator,
+        # with the receiver as the left hand side and the argument as the right hand side.
+        def is_distinct_from(rhs)
+          BooleanExpression.new(:NOOP, IsDistinctFrom.new(self, rhs))
+        end
+      end
+
+      # These methods are added to datasets using the is_distinct_from extension
+      # extension, for the purposes of correctly literalizing IsDistinctFrom
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the IS DISTINCT FROM expression to the SQL query.
+        def is_distinct_from_sql_append(sql, idf)
+          lhs = idf.lhs
+          rhs = idf.rhs
+
+          if supports_is_distinct_from?
+            sql << "("
+            literal_append(sql, lhs)
+            sql << " IS DISTINCT FROM "
+            literal_append(sql, rhs)
+            sql << ")"
+          elsif db.database_type == :derby && (lhs == nil || rhs == nil)
+            if lhs == nil && rhs == nil
+              sql << literal_false
+            elsif lhs == nil
+              literal_append(sql, ~Sequel.expr(rhs=>nil))
+            else
+              literal_append(sql, ~Sequel.expr(lhs=>nil))
+            end
+          else
+            literal_append(sql, Sequel.case({(Sequel.expr(lhs=>rhs) | [[lhs, nil], [rhs, nil]]) => 0}, 1) => 1)
+          end
+        end
+
+        private
+
+        # Whether the database supports IS DISTINCT FROM.
+        def supports_is_distinct_from?
+          if defined?(super)
+            return super
+          end
+        
+          case db.database_type
+          when :postgres, :h2
+            true
+          when :sqlite
+            db.sqlite_version >= 33900
+          else
+            false
+          end
+        end
+      end
+
+      # The left hand side of the IS DISTINCT FROM expression.
+      attr_reader :lhs
+
+      # The right hand side of the IS DISTINCT FROM expression.
+      attr_reader :rhs
+
+      def initialize(lhs, rhs)
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      to_s_method :is_distinct_from_sql
+    end
+  end
+
+  class SQL::GenericExpression
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  class LiteralString
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  Dataset.register_extension(:is_distinct_from, SQL::IsDistinctFrom::DatasetMethods)
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::SQL::IsDistinctFrom::Methods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::SQL::IsDistinctFrom::Methods
+    end
+  end
+end
+# :nocov:

data/lib/sequel/extensions/looser_typecasting.rb

@@ -8,6 +8,9 @@
 # :decimal :: use 0.0 for unsupported strings
 # :string :: silently allow hash and array conversion to string
 #
+# This also removes bytesize checks for string inputs for float, integer
+# and decimal conversions.
+#
 # To load the extension into the database:
 #
 #   DB.extension :looser_typecasting

data/lib/sequel/extensions/migration.rb

@@ -159,6 +159,19 @@ module Sequel
       migration.up = block
       migration.down = MigrationReverser.new.reverse(&block)
     end
+
+    # Creates a revert migration.  This is the same as creating
+    # the same block with +down+, but it also calls the block and attempts
+    # to create a +up+ block that will reverse the changes made by
+    # the block.  This is designed to revert the changes in the
+    # provided block.
+    #
+    # There are no guarantees that this will work perfectly
+    # in all cases, but it works for some simple cases.
+    def revert(&block)
+      migration.down = block
+      migration.up = MigrationReverser.new.reverse(&block)
+    end
   end
 
   # Handles the reversing of reversible migrations.  Basically records
@@ -270,6 +283,10 @@ module Sequel
     def rename_column(name, new_name)
       @actions << [:rename_column, new_name, name]
     end
+
+    def set_column_allow_null(name, allow_null=true)
+      @actions << [:set_column_allow_null, name, !allow_null]
+    end
   end
 
   # The preferred method for writing Sequel migrations, using a DSL:
@@ -377,7 +394,7 @@ module Sequel
     # Raise a NotCurrentError unless the migrator is current, takes the same
     # arguments as #run.
     def self.check_current(*args)
-      raise(NotCurrentError, 'migrator is not current') unless is_current?(*args)
+      raise(NotCurrentError, 'current migration version does not match latest available version') unless is_current?(*args)
     end
 
     # Return whether the migrator is current (i.e. it does not need to make
@@ -388,6 +405,9 @@ module Sequel
 
     # Migrates the supplied database using the migration files in the specified directory. Options:
     # :allow_missing_migration_files :: Don't raise an error if there are missing migration files.
+    #                                   It is very risky to use this option, since it can result in
+    #                                   the database schema version number not matching the expected
+    #                                   database schema.
     # :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.
@@ -475,11 +495,7 @@ module Sequel
         @use_transactions
       end
 
-      if use_trans
-        db.transaction(&block)
-      else
-        yield
-      end
+      db.transaction(:skip_transaction=>use_trans == false, &block)
     end
 
     # Load the migration file, raising an exception if the file does not define
@@ -542,7 +558,7 @@ module Sequel
 
       @direction = current < target ? :up : :down
 
-      if @direction == :down && @current >= @files.length
+      if @direction == :down && @current >= @files.length && !@allow_missing_migration_files
         raise Migrator::Error, "Missing migration version(s) needed to migrate down to target version (current: #{current}, target: #{target})"
       end
 
@@ -677,6 +693,13 @@ module Sequel
       @migration_tuples = get_migration_tuples
     end
 
+    # Apply the migration in the given file path.  See Migrator.run for the
+    # available options.  Additionally, this method supports the :direction
+    # option for whether to run the migration up (default) or down.
+    def self.run_single(db, path, opts=OPTS)
+      new(db, File.dirname(path), opts).run_single(path, opts[:direction] || :up)
+    end
+
     # The timestamp migrator is current if there are no migrations to apply
     # in either direction.
     def is_current?
@@ -686,20 +709,39 @@ module Sequel
     # 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}")
-        checked_transaction(m) do
-          m.apply(db, direction)
-          fi = f.downcase
-          direction == :up ? ds.insert(column=>fi) : ds.where(column=>fi).delete
-        end
-        db.log_info("Finished applying migration #{f}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+        apply_migration(m, f, direction)
       end
       nil
     end
 
+    # Apply single migration tuple at the given path with the given direction
+    # on the database.
+    def run_single(path, direction)
+      migration = load_migration_file(path)
+      file_name = File.basename(path)
+      already_applied = applied_migrations.include?(file_name.downcase)
+
+      return if direction == :up ? already_applied : !already_applied
+
+      apply_migration(migration, file_name, direction)
+      nil
+    end
+
     private
 
+    # Apply a single migration with the given filename in the given direction.
+    def apply_migration(migration, file_name, direction)
+      fi = file_name.downcase
+      t = Time.now
+
+      db.log_info("Begin applying migration #{file_name}, direction: #{direction}")
+      checked_transaction(migration) do
+        migration.apply(db, direction)
+        direction == :up ? ds.insert(column=>fi) : ds.where(column=>fi).delete
+      end
+      db.log_info("Finished applying migration #{file_name}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+    end
+
     # 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