sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/migration.rb

@@ -41,7 +41,7 @@ module Sequel
     # direction.
     def self.apply(db, direction)
       raise(ArgumentError, "Invalid migration direction specified (#{direction.inspect})") unless [:up, :down].include?(direction)
-      new(db).send(direction)
+      new(db).public_send(direction)
     end
 
     # Returns the list of Migration descendants.
@@ -65,8 +65,12 @@ module Sequel
     
     # Intercepts method calls intended for the database and sends them along.
     def method_missing(method_sym, *args, &block)
+      # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
+    # :nocov:
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
 
     # This object responds to all methods the database responds to.
     def respond_to_missing?(meth, include_private)
@@ -99,29 +103,29 @@ module Sequel
     end
 
     # Apply the appropriate block on the +Database+
-    # instance using instance_eval.
+    # instance using instance_exec.
     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)
+      if prok = public_send(direction)
+        db.instance_exec(&prok)
       end
     end
   end
 
   # Internal class used by the Sequel.migration DSL, part of the +migration+ extension.
   class MigrationDSL < BasicObject
-    # The underlying Migration instance
+    # The underlying SimpleMigration instance
     attr_reader :migration
 
     def self.create(&block)
       new(&block).migration
     end
 
-    # Create a new migration class, and instance_eval the block.
+    # Create a new migration class, and instance_exec the block.
     def initialize(&block)
       @migration = SimpleMigration.new
       Migration.descendants << migration
-      instance_eval(&block)
+      instance_exec(&block)
     end
 
     # Defines the migration's down action.
@@ -150,7 +154,7 @@ module Sequel
     # the block.
     #
     # There are no guarantees that this will work perfectly
-    # in all cases, but it should work for most common cases.
+    # in all cases, but it works for some simple cases.
     def change(&block)
       migration.up = block
       migration.down = MigrationReverser.new.reverse(&block)
@@ -170,22 +174,19 @@ module Sequel
     # the given block.
     def reverse(&block)
       begin
-        instance_eval(&block)
+        instance_exec(&block)
       rescue
         just_raise = true
       end
       if just_raise
-        Proc.new{raise Sequel::Error, 'irreversible migration method used, you may need to write your own down method'}
+        Proc.new{raise Sequel::Error, "irreversible migration method used in #{block.source_location.first}, you may need to write your own down method"}
       else
         actions = @actions.reverse
         Proc.new do
           actions.each do |a|
-            if a.last.is_a?(Proc)
-              pr = a.pop
-              send(*a, &pr)
-            else
-              send(*a)
-            end
+            pr = a.last.is_a?(Proc) ? a.pop : nil
+            # Allow calling private methods as the reversing methods are private
+            send(*a, &pr)
           end
         end
       end
@@ -233,8 +234,9 @@ module Sequel
     end
 
     def reverse(&block)
-      instance_eval(&block)
+      instance_exec(&block)
       actions = @actions.reverse
+      # Allow calling private methods as the reversing methods are private
       Proc.new{actions.each{|a| send(*a)}}
     end
 
@@ -245,7 +247,9 @@ module Sequel
     end
 
     def add_constraint(*args)
-      @actions << [:drop_constraint, args.first]
+      name = args.first
+      name = name.is_a?(Hash) ? name[:name] : name
+      @actions << [:drop_constraint, name]
     end
 
     def add_foreign_key(key, table, *args)
@@ -328,30 +332,32 @@ module Sequel
   # 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
+  # specified, or the target version specified is greater than the latest
+  # version available, the database is migrated to the latest version available in the
   # migration directory.
   #
   # For example, to migrate the database to the latest version:
   #
-  #   Sequel::Migrator.apply(DB, '.')
+  #   Sequel::Migrator.run(DB, '.')
   #
   # For example, to migrate the database all the way down:
   #
-  #   Sequel::Migrator.apply(DB, '.', 0)
+  #   Sequel::Migrator.run(DB, '.', target: 0)
   #
   # For example, to migrate the database to version 4:
   #
-  #   Sequel::Migrator.apply(DB, '.', 4)
+  #   Sequel::Migrator.run(DB, '.', target: 4)
   #
   # To migrate the database from version 1 to version 5:
   #
-  #   Sequel::Migrator.apply(DB, '.', 5, 1)
+  #   Sequel::Migrator.run(DB, '.', target: 5, current: 1)
   #
   # Part of the +migration+ extension.
   class Migrator
     MIGRATION_FILE_PATTERN = /\A(\d+)_.+\.rb\z/i.freeze
-    MIGRATION_SPLITTER = '_'.freeze
-    MINIMUM_TIMESTAMP = 20000101
+
+    # Mutex used around migration file loading
+    MUTEX = Mutex.new
 
     # Exception class raised when there is an error with the migrator's
     # file structure, database, or arguments.
@@ -382,29 +388,35 @@ 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.
-    # :table :: The table containing the schema version (default: :schema_info).
+    # :relative :: Run the given number of migrations, with a positive number being migrations to migrate
+    #              up, and a negative number being migrations to migrate down (IntegerMigrator only).
+    # :table :: The table containing the schema version (default: :schema_info for integer migrations and
+    #           :schema_migrations for timestamped migrations).
     # :target :: The target version to which to migrate.  If not given, migrates to the maximum version.
     #
     # Examples: 
     #   Sequel::Migrator.run(DB, "migrations")
-    #   Sequel::Migrator.run(DB, "migrations", :target=>15, :current=>10)
-    #   Sequel::Migrator.run(DB, "app1/migrations", :column=> :app2_version)
-    #   Sequel::Migrator.run(DB, "app2/migrations", :column => :app2_version, :table=>:schema_info2)
+    #   Sequel::Migrator.run(DB, "migrations", target: 15, current: 10)
+    #   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=OPTS)
       migrator_class(directory).new(db, directory, opts).run
     end
 
     # 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.
+    # if the version number is greater than 20000101, otherwise uses the IntegerMigrator.
     def self.migrator_class(directory)
       if self.equal?(Migrator)
+        raise(Error, "Must supply a valid migration path") unless File.directory?(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
+          return TimestampMigrator if file.split('_', 2).first.to_i > 20000101
         end
         IntegerMigrator
       else
@@ -444,9 +456,9 @@ module Sequel
       @directory = directory
       @allow_missing_migration_files = opts[:allow_missing_migration_files]
       @files = get_migration_files
-      schema, table = @db.send(:schema_and_table, opts[:table]  || self.class.const_get(:DEFAULT_SCHEMA_TABLE))
+      schema, table = @db.send(:schema_and_table, opts[:table] || default_schema_table)
       @table = schema ? Sequel::SQL::QualifiedIdentifier.new(schema, table) : table
-      @column = opts[:column] || self.class.const_get(:DEFAULT_SCHEMA_COLUMN)
+      @column = opts[:column] || default_schema_column
       @ds = schema_dataset
       @use_transactions = opts[:use_transactions]
     end
@@ -476,24 +488,21 @@ module Sequel
     # Load the migration file, raising an exception if the file does not define
     # a single migration.
     def load_migration_file(file)
-      n = Migration.descendants.length
-      load(file)
-      raise Error, "Migration file not containing a single migration detected" unless n + 1 == Migration.descendants.length
-    end
-
-    # 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
+      MUTEX.synchronize do
+        n = Migration.descendants.length
+        load(file)
+        raise Error, "Migration file #{file.inspect} not containing a single migration detected" unless n + 1 == Migration.descendants.length
+        c = Migration.descendants.pop
+        if c.is_a?(Class) && !c.name.to_s.empty? && Object.const_defined?(c.name)
+          Object.send(:remove_const, c.name)
+        end
+        c
       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
+      filename.split('_', 2).first.to_i
     end
   end
 
@@ -501,9 +510,6 @@ module Sequel
   # 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
@@ -518,13 +524,31 @@ module Sequel
     # Set up all state for the migrator instance
     def initialize(db, directory, opts=OPTS)
       super
-      @target = opts[:target] || latest_migration_version
       @current = opts[:current] || current_migration_version
 
-      raise(Error, "No current version available") unless current
-      raise(Error, "No target version available, probably because no migration files found or filenames don't follow the migration filename convention") unless target
+      latest_version = latest_migration_version
+      @target = if opts[:target]
+        opts[:target]
+      elsif opts[:relative]
+        @current + opts[:relative]
+      else
+        latest_version
+      end
+
+      raise(Error, "No target and/or latest version available, probably because no migration files found or filenames don't follow the migration filename convention") unless target && latest_version
+
+      if @target > latest_version
+        @target = latest_version
+      elsif @target < 0
+        @target = 0
+      end
 
       @direction = current < target ? :up : :down
+
+      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
+
       @migrations = get_migrations
     end
 
@@ -536,13 +560,13 @@ module Sequel
     # Apply all migrations on the database
     def run
       migrations.zip(version_numbers).each do |m, v|
-        t = Time.now
+        timer = Sequel.start_timer
         db.log_info("Begin applying migration version #{v}, direction: #{direction}")
         checked_transaction(m) do
           m.apply(db, direction)
           set_migration_version(up? ? v : v-1)
         end
-        db.log_info("Finished applying migration version #{v}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+        db.log_info("Finished applying migration version #{v}, direction: #{direction}, took #{sprintf('%0.6f', Sequel.elapsed_seconds_since(timer))} seconds")
       end
       
       target
@@ -556,6 +580,16 @@ module Sequel
       ds.get(column) || 0
     end
 
+    # The default column storing schema version.
+    def default_schema_column
+      :version
+    end
+
+    # The default table storing schema version.
+    def default_schema_table
+      :schema_info
+    end
+
     # Returns any found migration files in the supplied directory.
     def get_migration_files
       files = []
@@ -575,13 +609,7 @@ module Sequel
     # Returns a list of migration classes filtered for the migration range and
     # ordered according to the migration direction.
     def get_migrations
-      remove_migration_classes
-
-      # load migration files
-      version_numbers.each{|n| load_migration_file(files[n])}
-      
-      # get migration classes
-      Migration.descendants
+      version_numbers.map{|n| load_migration_file(files[n])}
     end
     
     # Returns the latest version available in the specified directory.
@@ -604,7 +632,7 @@ module Sequel
       ds
     end
     
-    # Sets the current migration  version stored in the database.
+    # Sets the current migration version stored in the database.
     def set_migration_version(version)
       ds.update(column=>version)
     end
@@ -630,15 +658,12 @@ module Sequel
     end
   end
 
-  # The migrator used if any migration file version appears to be a timestamp.
+  # The migrator used if any migration file version is greater than 20000101.
   # 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
@@ -669,7 +694,7 @@ module Sequel
         checked_transaction(m) do
           m.apply(db, direction)
           fi = f.downcase
-          direction == :up ? ds.insert(column=>fi) : ds.filter(column=>fi).delete
+          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")
       end
@@ -681,7 +706,7 @@ module Sequel
     # 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)
+      v = db[:schema_info].get(:version)
       ds = db.from(table)
       files.each do |path|
         f = File.basename(path)
@@ -691,6 +716,16 @@ module Sequel
       end
     end
 
+    # The default column storing migration filenames.
+    def default_schema_column
+      :filename
+    end
+
+    # The default table storing migration filenames.
+    def default_schema_table
+      :schema_migrations
+    end
+
     # Returns filenames of all applied migrations
     def get_applied_migrations
       am = ds.select_order_map(column)
@@ -711,26 +746,21 @@ module Sequel
     
     # 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_migration_file(path)
-              down_mts << [ms.last, f, :down]
+              down_mts << [load_migration_file(path), f, :down]
             end
           elsif !applied_migrations.include?(fi)
-            load_migration_file(path)
-            up_mts << [ms.last, f, :up]
+            up_mts << [load_migration_file(path), f, :up]
           end
         elsif !applied_migrations.include?(fi)
-          load_migration_file(path)
-          up_mts << [ms.last, f, :up]
+          up_mts << [load_migration_file(path), f, :up]
         end
       end
       up_mts + down_mts.reverse
@@ -742,7 +772,18 @@ module Sequel
       c = column
       ds = db.from(table)
       if !db.table_exists?(table)
-        db.create_table(table){String c, :primary_key=>true}
+        begin
+          db.create_table(table){String c, :primary_key=>true}
+        rescue Sequel::DatabaseError => e
+          if db.database_type == :mysql && e.message =~ /max key length/
+            # Handle case where MySQL is used with utf8mb4 charset default, which
+            # only allows a maximum length of about 190 characters for string
+            # primary keys due to InnoDB limitations.
+            db.create_table(table){String c, :primary_key=>true, :size=>190}
+          else
+            raise e
+          end
+        end
         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

data/lib/sequel/extensions/named_timezones.rb

@@ -2,18 +2,21 @@
 #
 # Allows the use of named timezones via TZInfo (requires tzinfo).
 # Forces the use of DateTime as Sequel's datetime_class, since
-# ruby's Time class doesn't support timezones other than local
-# and UTC.
+# historically, Ruby's Time class doesn't support timezones other
+# than local and UTC. To continue using Ruby's Time class when using
+# the named_timezones extension:
+#
+#   # Load the extension
+#   Sequel.extension :named_timezones
+#
+#   # Set Sequel.datetime_class back to Time
+#   Sequel.datetime_class = Time
 #
 # This allows you to either pass strings or TZInfo::Timezone
 # instance to Sequel.database_timezone=, application_timezone=, and
 # typecast_timezone=.  If a string is passed, it is converted to a
 # TZInfo::Timezone using TZInfo::Timezone.get.
 #
-# To load the extension:
-#
-#   Sequel.extension :named_timezones
-#
 # Let's say you have the database server in New York and the
 # application server in Los Angeles.  For historical reasons, data
 # is stored in local New York time, but the application server only
@@ -37,7 +40,8 @@
 # Note that typecasting from the database timezone to the application
 # timezone when fetching rows is dependent on the database adapter,
 # and only works on adapters where Sequel itself does the conversion.
-# It should work on mysql, postgres, sqlite, ibmdb, and jdbc.
+# It should work with the mysql, postgres, sqlite, ibmdb, and jdbc
+# adapters.
 #
 # Related module: Sequel::NamedTimezones
 
@@ -63,24 +67,85 @@ module Sequel
 
     private 
     
-    # Assume the given DateTime has a correct time but a wrong timezone.  It is
-    # currently in UTC timezone, but it should be converted to the input_timezone.
-    # Keep the time the same but convert the timezone to the input_timezone.
-    # Expects the input_timezone to be a TZInfo::Timezone instance.
-    def convert_input_datetime_other(v, input_timezone)
-      local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
-      (v - local_offset).new_offset(local_offset)
+    if RUBY_VERSION >= '2.6'
+      # Convert the given input Time (which must be in UTC) to the given input timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_input_time_other(v, input_timezone)
+        Time.new(v.year, v.mon, v.day, v.hour, v.min, (v.sec + Rational(v.nsec, 1000000000)), input_timezone)
+      rescue TZInfo::AmbiguousTime
+        raise unless disamb = tzinfo_disambiguator_for(v)
+        period = input_timezone.period_for_local(v, &disamb)
+        offset = period.utc_total_offset
+        Time.at(v.to_i - offset, :in => input_timezone)
+      end
+
+      # Convert the given input Time to the given output timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_output_time_other(v, output_timezone)
+        Time.at(v.to_i, :in => output_timezone)
+      end
+      # :nodoc:
+      # :nocov:
+    else
+      def convert_input_time_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+      end
+
+      if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + local_offset
+        end
+      else
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+        end
+      end
+      # :nodoc:
+      # :nocov:
     end
 
-    # Convert the given DateTime to use the given output_timezone.
-    # Expects the output_timezone to be a TZInfo::Timezone instance.
-    def convert_output_datetime_other(v, output_timezone)
-      # TZInfo converts times, but expects the given DateTime to have an offset
-      # of 0 and always leaves the timezone offset as 0
-      v = output_timezone.utc_to_local(v.new_offset(0))
-      local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
-      # Convert timezone offset from UTC to the offset for the output_timezone
-      (v - local_offset).new_offset(local_offset)
+    # Handle both TZInfo 1 and TZInfo 2
+    if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+      def convert_input_datetime_other(v, input_timezone)
+        local_offset = Rational(input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset, 86400)
+        (v - local_offset).new_offset(local_offset)
+      end
+
+      def convert_output_datetime_other(v, output_timezone)
+        v = output_timezone.utc_to_local(v.new_offset(0))
+
+        # Force DateTime output instead of TZInfo::DateTimeWithOffset
+        DateTime.jd(v.jd, v.hour, v.minute, v.second + v.sec_fraction, v.offset, v.start)
+      end
+      # :nodoc:
+      # :nocov:
+    else
+      # Assume the given DateTime has a correct time but a wrong timezone.  It is
+      # currently in UTC timezone, but it should be converted to the input_timezone.
+      # Keep the time the same but convert the timezone to the input_timezone.
+      # Expects the input_timezone to be a TZInfo::Timezone instance.
+      def convert_input_datetime_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
+        (v - local_offset).new_offset(local_offset)
+      end
+
+      # Convert the given DateTime to use the given output_timezone.
+      # Expects the output_timezone to be a TZInfo::Timezone instance.
+      def convert_output_datetime_other(v, output_timezone)
+        # TZInfo 1 converts times, but expects the given DateTime to have an offset
+        # of 0 and always leaves the timezone offset as 0
+        v = output_timezone.utc_to_local(v.new_offset(0))
+        local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
+        # Convert timezone offset from UTC to the offset for the output_timezone
+        (v - local_offset).new_offset(local_offset)
+      end
+      # :nodoc:
+      # :nocov:
     end
     
     # Returns TZInfo::Timezone instance if given a String.

data/lib/sequel/extensions/no_auto_literal_strings.rb

@@ -1,84 +1,4 @@
 # frozen-string-literal: true
-#
-# The no_auto_literal_strings extension removes Sequel's automatic conversion
-# of strings to literal strings in the dataset filter methods.  By default,
-# Sequel considers a string passed to a filter method as a literal string:
-#
-#   DB[:table].where("name > 'A'")
-#
-# This is fine, except when the string is derived from user input:
-#
-#   DB[:table].where("name > '#{params[:user]}'") # SQL Injection!
-#
-# Sequel does support using placeholders for such strings:
-#
-#   DB[:table].where("name > ?", params[:user].to_s) # Safe
-#
-# However, if you forget to user placeholders, and pass a string to a filter
-# method that is derived from user input, you open yourself up to SQL injection.
-# With this extension, using a plain string in a filter method will result
-# in an exception being raised.  You either need to explicitly use a literal
-# string:
-#
-#   DB[:table].where(Sequel.lit("name > ?", params[:user].to_s))
-#
-# or you need to construct the same SQL using a non-string based approach:
-#
-#   DB[:table].where{|o| o.name > params[:user].to_s}
-#
-# Note that as listed in Sequel's security guide, a large number of dataset
-# methods call down to a filtering method, and this protects all of those
-# cases.
-#
-# This extension also protects the use of a plain string passed to Dataset#update:
-#
-#   DB[:table].update("column = column + 1")
-#
-# Again, you either need to explicitly use a literal string:
-#
-#   DB[:table].update(Sequel.lit("column = column + 1"))
-#
-# or construct the same SQL using a non-string based approach:
-#
-#   DB[:table].update(:column => Sequel.expr(:column) + 1)
-#
-# Related module: Sequel::Dataset::NoAutoLiteralStrings
 
-#
-module Sequel
-  class Dataset
-    module NoAutoLiteralStrings
-      # Raise an error if passing a plain string or an array whose first
-      # entry is a plain string.
-      def filter_expr(expr = nil)
-        case expr
-        when LiteralString
-          super
-        when String
-          raise Error, "plain string passed to a dataset filtering method"
-        when Array
-          if expr.first.is_a?(String) && !expr.first.is_a?(LiteralString)
-            raise Error, "plain string passed to a dataset filtering method"
-          end
-          super
-        else
-          super
-        end
-      end
-
-      # Raise an error if passing a plain string.
-      def update_sql(values=OPTS)
-        case values
-        when LiteralString
-          super
-        when String
-          raise Error, "plain string passed to a dataset filtering method"
-        else
-          super
-        end
-      end
-    end
-
-    register_extension(:no_auto_literal_strings, NoAutoLiteralStrings)
-  end
-end
+Sequel::Database.register_extension(:no_auto_literal_strings){}
+Sequel::Dataset.register_extension(:no_auto_literal_strings){}