sequel 5.108.0 → 5.110.0

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

@@ -305,38 +305,6 @@ module Sequel
           super(sql, :+, args)
         when :<<, :>>
           complex_expression_emulate_append(sql, op, args)
-        when :LIKE, :"NOT LIKE"
-          sql << '('
-          literal_append(sql, args[0])
-          sql << (op == :LIKE ? ' REGEXP ' : ' NOT REGEXP ')
-          pattern = String.new
-          last_c = ''
-          args[1].each_char do |c|
-            if  c == '_' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '.'
-            elsif c == '%' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '.*'
-            elsif c == '[' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\['
-            elsif c == ']' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\]'
-            elsif c == '*' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\*'
-            elsif c == '?' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\?'
-            else
-              pattern << c
-            end
-            if c == '\\' and last_c == '\\'
-              last_c = ''
-            else
-              last_c = c
-            end
-          end
-          literal_append(sql, pattern)
-          sql << " ESCAPE "
-          literal_append(sql, "\\")
-          sql << ')'
         when :ILIKE, :"NOT ILIKE"
           super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args)
         when :extract

data/lib/sequel/adapters/sqlite.rb

@@ -336,16 +336,20 @@ module Sequel
           log_sql << sql
           log_sql << ")"
         end
-        if block
-          log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
-        else
-          log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
-          case type
-          when :insert
-            conn.last_insert_row_id
-          when :update
-            conn.changes
+        begin
+          if block
+            log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
+          else
+            log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
+            case type
+            when :insert
+              conn.last_insert_row_id
+            when :update
+              conn.changes
+            end
           end
+        ensure
+          cps.clear_bindings!
         end
       end
       

data/lib/sequel/adapters/trilogy.rb

@@ -62,7 +62,8 @@ module Sequel
       private
 
       def database_specific_error_class(exception, opts)
-        if exception.error_code == 1205
+        case exception.error_code
+        when 1205, 3572
           DatabaseLockTimeout
         else
           super

data/lib/sequel/core.rb

@@ -10,7 +10,7 @@
 #   DB = Sequel.sqlite # Memory database
 #   DB = Sequel.sqlite('blog.db')
 #   DB = Sequel.postgres('database_name',
-#          user:'user', 
+#          user: 'user', 
 #          password: 'password',
 #          host: 'host'
 #          port: 5432, 
@@ -25,7 +25,7 @@
 # For a more expanded introduction, see the {README}[rdoc-ref:README.rdoc].
 # For a quicker introduction, see the {cheat sheet}[rdoc-ref:doc/cheat_sheet.rdoc].
 module Sequel
-  @convert_two_digit_years = true
+  @convert_two_digit_years = true # SEQUEL6: Remove
   @datetime_class = Time # SEQUEL6: Remove
   @split_symbols = false # SEQUEL6: Remove
   @single_threaded = false
@@ -37,6 +37,8 @@ module Sequel
   OPTS = {}.freeze
 
   SPLIT_SYMBOL_CACHE = {}  # SEQUEL6: Remove
+  SPLIT_SYMBOL_CACHE_ = SPLIT_SYMBOL_CACHE
+  private_constant :SPLIT_SYMBOL_CACHE_
 
   module SequelMethods
     # Sequel converts two digit years in <tt>Date</tt>s and <tt>DateTime</tt>s by default,
@@ -45,7 +47,16 @@ module Sequel
     # January 2nd, 0003 and December 13, 0099, respectively, by:
     #
     #   Sequel.convert_two_digit_years = false
-    attr_accessor :convert_two_digit_years
+    #
+    # The setter method is deprecated and will be removed in Sequel 6.
+    # The reader method will be deprecated in Sequel 6.0 and removed in
+    # Sequel 6.1.
+    attr_reader :convert_two_digit_years # SEQUEL6.1: Remove
+
+    def convert_two_digit_years=(v)
+      Sequel::Deprecation.deprecate("Sequel.convert_two_digit_years= is deprecated and will be removed in Sequel 6.")
+      @convert_two_digit_years = v
+    end
 
     # Sequel can use either +Time+ or +DateTime+ for times returned from the
     # database.  It defaults to +Time+.  To change it to +DateTime+:
@@ -55,9 +66,16 @@ module Sequel
     # Note that +Time+ and +DateTime+ objects have a different API, and in
     # cases where they implement the same methods, they often implement them
     # differently (e.g. + using seconds on +Time+ and days on +DateTime+).
-    attr_accessor :datetime_class
-    # SEQUEL6: Remove datetime_class=
-    # SEQUEL6.1: Remove datetime_class
+    #
+    # The setter method is deprecated and will be removed in Sequel 6.
+    # The reader method will be deprecated in Sequel 6.0 and removed in
+    # Sequel 6.1.
+    attr_reader :datetime_class # SEQUEL6.1: Remove
+
+    def datetime_class=(v)
+      Sequel::Deprecation.deprecate("Sequel.datetime_class= is deprecated and will be removed in Sequel 6.")
+      @datetime_class = v
+    end
 
     # Set whether Sequel is being used in single threaded mode. By default,
     # Sequel uses a thread-safe connection pool, which isn't as fast as the
@@ -68,8 +86,8 @@ module Sequel
     #   Sequel.single_threaded = true
     attr_accessor :single_threaded
 
-    # # SEQUEL6: Remove
-    alias orig_require require
+    # SEQUEL6: Remove
+    define_method(:orig_require, Kernel.instance_method(:require))
     private :orig_require
 
     # Returns true if the passed object could be a specifier of conditions, false otherwise.
@@ -92,7 +110,7 @@ module Sequel
       end
     end
 
-    # Creates a new database object based on the supplied connection string
+    # Creates a new Database object based on the supplied connection string
     # and optional arguments.  The specified scheme determines the database
     # class used, and the rest of the string specifies the connection options.
     # For example:
@@ -156,18 +174,30 @@ module Sequel
     #   Sequel.extension(:blank)
     #   Sequel.extension(:core_extensions, :named_timezones)
     def extension(*extensions)
-      extensions.each{|e| orig_require("sequel/extensions/#{e}")}
+      extensions.each do |e|
+        e = e.to_s
+
+        if %r{..[/\\]} =~ e
+          raise Error, "cannot use extension with ../ for security reasons"
+        end
+
+        Kernel.require("sequel/extensions/#{e}")
+      end
     end
     
-    # The exception classed raised if there is an error parsing JSON.
+    # The exception class raised if there is an error parsing JSON.
     # This can be overridden to use an alternative json implementation.
-    def json_parser_error_class
+    #
+    # This method is deprecated and will be removed in Sequel 6.1.
+    def json_parser_error_class # SEQUEL6.1: Remove
       JSON::ParserError
     end
 
     if RUBY_VERSION >= '3'
       # Join the array or set.
-      def array_or_set_join(obj, arg)
+      #
+      # This method is deprecated and will be removed in Sequel 6.1.
+      def array_or_set_join(obj, arg) # SEQUEL6.1: Remove
         obj.join(arg)
       end
     # simplecov:disable
@@ -196,14 +226,22 @@ module Sequel
 
     # Convert given object to json and return the result.
     # This can be overridden to use an alternative json implementation.
-    def object_to_json(obj, *args, &block)
+    #
+    # This method is deprecated and will be removed in Sequel 6.1.
+    def object_to_json(obj, *args, &block) # SEQUEL6.1: Remove
       obj.to_json(*args, &block)
     end
 
     # Parse the string as JSON and return the result.
     # This can be overridden to use an alternative json implementation.
-    def parse_json(json)
-      JSON.parse(json, :create_additions=>false)
+    #
+    # This method is deprecated and will be removed in Sequel 6.1.
+    def parse_json(json) # SEQUEL6.1: Remove
+      if JSON::VERSION >= '3'
+        JSON.parse(json)
+      else
+        JSON.parse(json, :create_additions=>false)
+      end
     end
 
     # If a mutex is given, synchronize access using it.  If nil is given, just
@@ -249,7 +287,7 @@ module Sequel
     # For tables, these parts are the schema, table, and alias.
     def split_symbol(sym)
       # SEQUEL6.1: Remove
-      unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym]}
+      unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE_[sym]}
         if split_symbols?
           v = case s = sym.to_s
           when /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/
@@ -264,7 +302,7 @@ module Sequel
         else
           v = [nil,sym.to_s.freeze,nil].freeze
         end
-        Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym] = v}
+        Sequel.synchronize{SPLIT_SYMBOL_CACHE_[sym] = v}
       end
       v
     end
@@ -300,8 +338,8 @@ module Sequel
     #   Sequel.expr{table__column}  # table__column
     #   Sequel.expr{table[:column]} # table.column
     def split_symbols=(v)
-      # SEQUEL6: Remove
-      Sequel.synchronize{SPLIT_SYMBOL_CACHE.clear}
+      Sequel::Deprecation.deprecate("Sequel.split_symbols= is deprecated and will be removed in Sequel 6.")
+      Sequel.synchronize{SPLIT_SYMBOL_CACHE_.clear}
       @split_symbols = v
     end
 
@@ -324,7 +362,9 @@ module Sequel
     # value of <tt>Sequel.datetime_class</tt>.
     #
     #   Sequel.string_to_datetime('2010-09-10 10:20:30') # Time.local(2010, 09, 10, 10, 20, 30)
-    def string_to_datetime(string)
+    #
+    # This method is deprecated and will be removed in Sequel 6.1.
+    def string_to_datetime(string) # SEQUEL6.1: Remove
       if datetime_class == DateTime
         DateTime.parse(string, convert_two_digit_years)
       else
@@ -356,7 +396,10 @@ module Sequel
     if RUBY_VERSION >= '2.1'
       # A timer object that can be passed to Sequel.elapsed_seconds_since
       # to return the number of seconds elapsed.
-      def start_timer
+      #
+      # This method is deprecated and will be removed in Sequel 6.1 (or
+      # potentially in 6.0 if Ruby 2.1 support is dropped before 6.0).
+      def start_timer # SEQUEL6.1: Remove
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
     else
@@ -369,7 +412,10 @@ module Sequel
 
     # The elapsed seconds since the given timer object was created.  The
     # timer object should have been created via Sequel.start_timer.
-    def elapsed_seconds_since(timer)
+    #
+    # This method is deprecated and will be removed in Sequel 6.1 (or
+    # potentially in 6.0 if Ruby 2.1 support is dropped before 6.0).
+    def elapsed_seconds_since(timer) # SEQUEL6.1: Remove
       start_timer - timer
     end
 
@@ -481,4 +527,6 @@ module Sequel
 
   # Add the database adapter class methods to Sequel via metaprogramming
   def_adapter_method(*Database::ADAPTERS)
+
+  Deprecation.deprecate_constant(self, :SPLIT_SYMBOL_CACHE)
 end

data/lib/sequel/database/misc.rb

@@ -229,12 +229,7 @@ module Sequel
     end
 
     # Disallow dup/clone for Database instances
-    undef_method :dup, :clone, :initialize_copy
-    # simplecov:disable
-    if RUBY_VERSION >= '1.9.3'
-    # simplecov:enable
-      undef_method :initialize_clone, :initialize_dup
-    end
+    undef_method :dup, :clone, :initialize_copy, :initialize_clone, :initialize_dup
 
     # Cast the given type to a literal type
     #

data/lib/sequel/database/schema_methods.rb

@@ -170,18 +170,18 @@ module Sequel
     # :engine :: The table engine to use for the table.
     #
     # PostgreSQL specific options:
-    # :on_commit :: Either :preserve_rows (default), :drop or :delete_rows. Should
-    #               only be specified when creating a temporary table.
     # :foreign :: Create a foreign table.  The value should be the name of the
     #             foreign server that was specified in CREATE SERVER.
     # :inherits :: Inherit from a different table.  An array can be
     #              specified to inherit from multiple tables.
-    # :unlogged :: Create the table as an unlogged table.
+    # :on_commit :: Either :preserve_rows (default), :drop or :delete_rows. Should
+    #               only be specified when creating a temporary table.
     # :options :: The OPTIONS clause to use for foreign tables.  Should be a hash
     #             where keys are option names and values are option values.  Note
     #             that option names are unquoted, so you should not use untrusted
     #             keys.
     # :tablespace :: The tablespace to use for the table.
+    # :unlogged :: Create the table as an unlogged table.
     #
     # SQLite specific options:
     # :strict :: Create a STRICT table, which checks that the values for the columns

data/lib/sequel/database/transactions.rb

@@ -374,9 +374,7 @@ module Sequel
 
     # Whether to commit the current transaction. Thread.current.status is
     # checked because Thread#kill skips rescue blocks (so exception would be
-    # nil), but the transaction should still be rolled back. On Ruby 1.9 (but
-    # not 2.0+), the thread status will still be "run", so Thread#kill
-    # will erroneously commit the transaction, and there isn't a workaround.
+    # nil), but the transaction should still be rolled back.
     def commit_or_rollback_transaction(exception, conn, opts)
       if exception
         false

data/lib/sequel/dataset/actions.rb

@@ -242,7 +242,7 @@ module Sequel
         end
       when 1
         arg = args[0]
-        if arg.is_a?(Integer)
+        if arg.is_a?(Integer) && arg >= 0
           res = if block
             if loader = cached_placeholder_literalizer(:_first_integer_cond_loader) do |pl|
                 where(pl.arg).limit(pl.arg)

data/lib/sequel/dataset/sql.rb

@@ -1346,10 +1346,21 @@ module Sequel
     alias delete_returning_sql insert_returning_sql
     alias update_returning_sql insert_returning_sql
 
-    # SQL fragment specifying a JOIN type, converts underscores to
-    # spaces and upcases.
+    JOIN_TYPE_SQL = {}
+    (CONDITIONED_JOIN_TYPES + UNCONDITIONED_JOIN_TYPES + %i[natural_inner natural_left_outer natural_right_outer natural_full_outer]).each do |join_type|
+      JOIN_TYPE_SQL[join_type] = "#{join_type.to_s.tr('_', ' ').upcase} JOIN".freeze
+    end
+    JOIN_TYPE_SQL[nil] = "JOIN"
+    JOIN_TYPE_SQL.freeze
+    private_constant :JOIN_TYPE_SQL
+
+    # SQL fragment for join type
     def join_type_sql(join_type)
-      "#{join_type.to_s.tr('_', ' ').upcase} JOIN"
+      JOIN_TYPE_SQL.fetch(join_type) do
+        # SEQUEL6: Raise error
+        Sequel::Deprecation.deprecate("Unrecognized join type used: #{join_type.inspect}. This will raise an error starting in Sequel 6.")
+        "#{join_type.to_s.tr('_', ' ').upcase} JOIN"
+      end
     end
 
     # Append USING clause for JOIN USING

data/lib/sequel/extensions/core_refinements.rb

@@ -10,10 +10,7 @@
 #
 #   using Sequel::CoreRefinements
 
-# simplecov:disable
-raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
-# simplecov:enable
-
+#
 module Sequel::CoreRefinements
   # simplecov:disable
   include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include

data/lib/sequel/extensions/current_datetime_timestamp.rb

@@ -38,7 +38,7 @@ module Sequel
       private
 
       # Literalize custom DateTime subclass objects as CURRENT_TIMESTAMP.
-      def literal_datetime_append(sql, v)
+      def literal_datetime_append(sql, v) # SEQUEL6: Remove
         v.is_a?(DateTime) ? literal_append(sql, Sequel::CURRENT_TIMESTAMP) : super
       end
 
@@ -52,7 +52,7 @@ module Sequel
     class Time < ::Time; end
 
     # DateTime subclass literalized as CURRENT_TIMESTAMP
-    class DateTime < ::DateTime; end
+    class DateTime < ::DateTime; end # SEQUEL6.1: Remove
   end
 
   Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -40,9 +40,7 @@
 
 module Sequel
   module DuplicateColumnsHandler
-    # simplecov:disable
-    CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
-    # simplecov:enable
+    CALLER_ARGS = [0,1].freeze
 
     # 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 defined?(yield); nil), &block)

data/lib/sequel/extensions/lit_require_frozen.rb

@@ -63,6 +63,20 @@ module Sequel
     class Error < Sequel::Error
     end
 
+    module BooleanExpressionClassMethods
+      private
+
+      # Do not freeze literal strings in value pairs, so they don't skip
+      # the frozen checks.
+      def from_value_pair(l, r)
+        if LiteralString === r
+          new(:'=', l, r)
+        else
+          super
+        end
+      end
+    end
+
     module DatabaseMethods
       def self.extended(db)
         db.extend_datasets(DatasetMethods)
@@ -105,7 +119,7 @@ module Sequel
       def _check_unfrozen_literal_string(str)
         return if !str.is_a?(String) || str.frozen?
 
-        if str.is_a?(LiteralString)
+        if str.is_a?(LiteralString) && str == str.source
           _check_unfrozen_literal_string(str.source)
         else
           raise Error, "cannot treat unfrozen string as literal SQL: #{str.inspect}"
@@ -126,6 +140,8 @@ module Sequel
     end
   end
 
+  SQL::BooleanExpression.extend(LitRequireFrozen::BooleanExpressionClassMethods)
+
   Dataset.register_extension(:lit_require_frozen, LitRequireFrozen::DatasetMethods)
   Database.register_extension(:lit_require_frozen, LitRequireFrozen::DatabaseMethods)
 end

data/lib/sequel/extensions/named_timezones.rb

@@ -1,17 +1,17 @@
 # frozen-string-literal: true
 #
 # Allows the use of named timezones via TZInfo (requires tzinfo).
-# Forces the use of DateTime as Sequel's datetime_class, since
+# Forces the use of DateTime as Sequel's datetime_class by default, since
 # 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:
+# the named_timezones extension, set the
+# +SEQUEL_NAMED_TIMEZONES_USE_TIME+ environment variable before
+# loading the extension:
 #
 #   # Load the extension
+#   ENV['SEQUEL_NAMED_TIMEZONES_USE_TIME'] = "1"
 #   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
@@ -49,7 +49,9 @@ require 'tzinfo'
 
 #
 module Sequel
-  self.datetime_class = DateTime
+  # simplecov:disable
+  self.datetime_class = DateTime unless ENV["SEQUEL_NAMED_TIMEZONES_USE_TIME"]
+  # simplecov:enable
   
   module NamedTimezones
     module DatabaseMethods
@@ -69,7 +71,7 @@ module Sequel
     
     if RUBY_VERSION >= '2.6'
       # Whether Time.at with :nsec and :in is broken.  True on JRuby < 9.3.9.0.
-      BROKEN_TIME_AT_WITH_NSEC = defined?(JRUBY_VERSION) && (JRUBY_VERSION < '9.3' || (JRUBY_VERSION < '9.4' && JRUBY_VERSION.split('.')[2].to_i < 9))
+      BROKEN_TIME_AT_WITH_NSEC = defined?(JRUBY_VERSION) && (JRUBY_VERSION.to_r < Rational('9.3') || (JRUBY_VERSION.to_r < Rational('9.4') && JRUBY_VERSION.split('.')[2].to_i < 9))
       private_constant :BROKEN_TIME_AT_WITH_NSEC
 
       # Convert the given input Time (which must be in UTC) to the given input timezone,

data/lib/sequel/extensions/pg_array.rb

@@ -390,6 +390,7 @@ module Sequel
               elsif char == '{'
                 raise Sequel::Error, "invalid array, opening brace with existing recorded data" unless @recorded.empty?
 
+                raise Sequel::Error, "cannot parse array with more than 6 dimensions" if @stack.length >= 6
                 # Start of new array, add it to the stack
                 new = []
                 @stack.last << new

data/lib/sequel/extensions/pg_json_ops.rb

@@ -984,7 +984,8 @@ module Sequel
               comma = true
             end
             ds.literal_append(sql, v)
-            sql << " AS " << k.to_s
+            sql << " AS "
+            ds.send(:identifier_append, sql, k)
           end
         end
       end
@@ -1254,7 +1255,8 @@ module Sequel
               comma = true
             end
             ds.literal_append(sql, v)
-            sql << " AS " << k.to_s
+            sql << " AS "
+            ds.send(:identifier_append, sql, k)
           end
         end
 

data/lib/sequel/extensions/pg_loose_count.rb

@@ -10,7 +10,11 @@
 #
 #   DB.loose_count(Sequel[:schema][:table]) # => 123456
 #
-# How accurate this count is depends on the number of rows
+# To get the loose count of all tables in a given schema:
+#
+#   DB.loose_counts(:schema) # => {table: 123456, ...}
+#
+# How accurate these counts are depends on the number of rows
 # added/deleted from the table since the last time it was
 # analyzed. If the table has not been vacuumed or analyzed
 # yet, this can return 0 or -1 depending on the PostgreSQL
@@ -31,9 +35,40 @@ module Sequel
       def loose_count(table)
         from(:pg_class).where(:oid=>regclass_oid(table)).get(Sequel.cast(:reltuples, Integer))
       end
+
+      # Look at the table statistics for the given schema and return a
+      # hash with table name keys and approximate counts. Results include
+      # normal tables, materialized views, and partitioned tables.
+      def loose_counts(schema)
+        case schema
+        when Symbol
+          schema = schema.to_s
+        when String
+          nil
+        when SQL::Identifier
+          schema = schema.value.to_s
+        else
+          raise Error, "unsupported argument type, should be symbol, string, or Sequel::SQL::Identifier, given #{schema.inspect}"
+        end
+
+        namespace_oid = if server_version >= 90500
+          Sequel.function(:to_regnamespace, schema).cast(:oid)
+        else
+          from(:pg_namespace).where(nspname: schema).select(:oid)
+        end
+
+        hash = {}
+        from(:pg_class).
+          where(relnamespace: namespace_oid, relkind: %w"r m p").
+          order(:relname).
+          select_map([:relname, Sequel.cast(:reltuples, Integer).as(:v)]).
+          each do |k, v|
+            hash[k.to_sym] = v
+          end
+        hash
+      end
     end
   end
 
   Database.register_extension(:pg_loose_count, Postgres::LooseCount)
 end
-

data/lib/sequel/extensions/s.rb

@@ -29,8 +29,7 @@
 #
 #   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
+# You can use also 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
@@ -39,7 +38,6 @@
 #
 # Related module: Sequel::S
 
-
 # 
 module Sequel::S
   private
@@ -50,11 +48,9 @@ module Sequel::S
   end
 
   # simplecov:disable
-  if RUBY_VERSION >= '2.0.0'
-    include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
+  include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
   # simplecov:enable
-    refine Object do
-      send include_meth, Sequel::S
-    end
+  refine Object do
+    send include_meth, Sequel::S
   end
 end

data/lib/sequel/extensions/schema_dumper.rb

@@ -200,8 +200,12 @@ END_MIG
 
     # Recreate the column in the passed Schema::CreateTableGenerator from the given name and parsed database schema.
     def recreate_column(name, schema, gen, options)
+      db_type = schema[:db_type]
+      db_type = literal(db_type) if options[:same_db] && database_type == :sqlite
+
       if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
-        type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
+        type_hash = options[:same_db] ? {:type=>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 == {:type=>"INTEGER"}
           type_hash.delete(:type)
@@ -220,7 +224,7 @@ END_MIG
         end
       else
         col_opts = if options[:same_db]
-          h = {:type=>schema[:db_type]}
+          h = {:type=>db_type}
           if database_type == :mysql && h[:type].start_with?("timestamp")
             h[:null] = true
           end

data/lib/sequel/extensions/sql_comments.rb

@@ -84,10 +84,6 @@
 #     # SELECT * FROM albums -- model:Album,action:all -- Some Comment
 #   end
 #
-# Note that Microsoft Access does not support inline comments,
-# and attempting to use comments on it will result in SQL syntax
-# errors.
-#
 # Related modules: Sequel::SQLComments, Sequel::Database::SQLComments
 
 #