sequel 5.60.1 → 5.62.0

data/lib/sequel/database/connecting.rb

@@ -241,6 +241,30 @@ module Sequel
       pool.servers
     end
 
+    # Connect to the given server/shard. Handles database-generic post-connection
+    # setup not handled by #connect, using the :after_connect and :connect_sqls
+    # options.
+    def new_connection(server)
+      conn = connect(server)
+      opts = server_opts(server)
+
+      if ac = opts[:after_connect]
+        if ac.arity == 2
+          ac.call(conn, server)
+        else
+          ac.call(conn)
+        end
+      end
+
+      if cs = opts[:connect_sqls]
+        cs.each do |sql|
+          log_connection_execute(conn, sql)
+        end
+      end
+
+      conn
+    end
+
     # Returns true if the database is using a single-threaded connection pool.
     def single_threaded?
       @single_threaded

data/lib/sequel/database/misc.rb

@@ -91,13 +91,23 @@ module Sequel
     # The specific default size of string columns for this Sequel::Database, usually 255 by default.
     attr_accessor :default_string_column_size
 
+    # Whether to check the bytesize of strings before typecasting (to avoid typecasting strings that
+    # would be too long for the given type), true by default. Strings that are too long will raise
+    # a typecasting error.
+    attr_accessor :check_string_typecast_bytesize
+
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
     # Accepts the following options:
+    # :after_connect :: A callable object called after each new connection is made, with the
+    #                   connection object (and server argument if the callable accepts 2 arguments),
+    #                   useful for customizations that you want to apply to all connections.
     # :before_preconnect :: Callable that runs after extensions from :preconnect_extensions are loaded,
     #                       but before any connections are created.
     # :cache_schema :: Whether schema should be cached for this Database instance
+    # :check_string_typecast_bytesize :: Whether to check the bytesize of strings before typecasting.
+    # :connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
     # :default_string_column_size :: The default size of string columns, 255 by default.
     # :extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
     #                or string with extensions separated by columns.  These extensions are loaded after
@@ -107,7 +117,7 @@ module Sequel
     # :loggers :: An array of loggers to use.
     # :log_connection_info :: Whether connection information should be logged when logging queries.
     # :log_warn_duration :: The number of elapsed seconds after which queries should be logged at warn level.
-    # :name :: A name to use for the Database object, displayed in PoolTimeout .
+    # :name :: A name to use for the Database object, displayed in PoolTimeout.
     # :preconnect :: Automatically create the maximum number of connections, so that they don't
     #                need to be created as needed.  This is useful when connecting takes a long time
     #                and you want to avoid possible latency during runtime.
@@ -116,13 +126,15 @@ module Sequel
     # :preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
     #                           connections are made by the :preconnect option.
     # :quote_identifiers :: Whether to quote identifiers.
-    # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol .
+    # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol.
     # :single_threaded :: Whether to use a single-threaded connection pool.
     # :sql_log_level :: Method to use to log SQL to a logger, :info by default.
     #
+    # For sharded connection pools, :after_connect and :connect_sqls can be specified per-shard.
+    #
     # All options given are also passed to the connection pool.  Additional options respected by
-    # the connection pool are :after_connect, :connect_sqls, :max_connections, :pool_timeout,
-    # :servers, and :servers_hash.  See the connection pool documentation for details.
+    # the connection pool are :max_connections, :pool_timeout, :servers, and :servers_hash.  See the
+    # connection pool documentation for details.
     def initialize(opts = OPTS)
       @opts ||= opts
       @opts = connection_pool_default_options.merge(@opts)
@@ -132,6 +144,7 @@ module Sequel
       @opts[:adapter_class] = self.class
       @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Sequel.single_threaded))
       @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
+      @check_string_typecast_bytesize = typecast_value_boolean(@opts.fetch(:check_string_typecast_bytesize, true))
 
       @schemas = {}
       @prepared_statements = {}
@@ -465,6 +478,21 @@ module Sequel
     #   Don't rescue other exceptions, they will be raised normally.
     end
 
+    # Check the bytesize of a string before conversion. There is no point
+    # trying to typecast strings that would be way too long.
+    def typecast_check_string_length(string, max_size)
+      if @check_string_typecast_bytesize && string.bytesize > max_size
+        raise InvalidValue, "string too long to typecast (bytesize: #{string.bytesize}, max: #{max_size})"
+      end
+      string
+    end
+
+    # Check the bytesize of the string value, if value is a string.
+    def typecast_check_length(value, max_size)
+      typecast_check_string_length(value, max_size) if String === value
+      value
+    end
+
     # Typecast the value to an SQL::Blob
     def typecast_value_blob(value)
       value.is_a?(Sequel::SQL::Blob) ? value : Sequel::SQL::Blob.new(value)
@@ -488,9 +516,9 @@ module Sequel
       when Date
         value
       when String
-        Sequel.string_to_date(value)
+        Sequel.string_to_date(typecast_check_string_length(value, 100))
       when Hash
-        Date.new(*[:year, :month, :day].map{|x| (value[x] || value[x.to_s]).to_i})
+        Date.new(*[:year, :month, :day].map{|x| typecast_check_length(value[x] || value[x.to_s], 100).to_i})
       else
         raise InvalidValue, "invalid value for Date: #{value.inspect}"
       end
@@ -498,7 +526,17 @@ module Sequel
 
     # Typecast the value to a DateTime or Time depending on Sequel.datetime_class
     def typecast_value_datetime(value)
-      Sequel.typecast_to_application_timestamp(value)
+      case value
+      when String
+        Sequel.typecast_to_application_timestamp(typecast_check_string_length(value, 100))
+      when Hash
+        [:year, :month, :day, :hour, :minute, :second, :nanos, :offset].each do |x|
+          typecast_check_length(value[x] || value[x.to_s], 100)
+        end
+        Sequel.typecast_to_application_timestamp(value)
+      else
+        Sequel.typecast_to_application_timestamp(value)
+      end
     end
     
     if RUBY_VERSION >= '2.4'
@@ -531,18 +569,30 @@ module Sequel
       when Numeric
         BigDecimal(value.to_s)
       when String
-        _typecast_value_string_to_decimal(value)
+        _typecast_value_string_to_decimal(typecast_check_string_length(value, 1000))
       else
         raise InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
       end
     end
 
     # Typecast the value to a Float
-    alias typecast_value_float Float
+    def typecast_value_float(value)
+      Float(typecast_check_length(value, 1000))
+    end
 
     # Typecast the value to an Integer
     def typecast_value_integer(value)
-      (value.is_a?(String) && value =~ /\A0+(\d)/) ? Integer(value, 10) : Integer(value)
+      case value
+      when String
+        typecast_check_string_length(value, 100)
+        if value =~ /\A-?0+(\d)/
+          Integer(value, 10)
+        else
+          Integer(value)
+        end
+      else
+        Integer(value)
+      end
     end
 
     # Typecast the value to a String
@@ -565,9 +615,9 @@ module Sequel
           SQLTime.create(value.hour, value.min, value.sec, value.nsec/1000.0)
         end
       when String
-        Sequel.string_to_time(value)
+        Sequel.string_to_time(typecast_check_string_length(value, 100))
       when Hash
-        SQLTime.create(*[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
+        SQLTime.create(*[:hour, :minute, :second].map{|x| typecast_check_length(value[x] || value[x.to_s], 100).to_i})
       else
         raise Sequel::InvalidValue, "invalid value for Time: #{value.inspect}"
       end

data/lib/sequel/database/query.rb

@@ -175,6 +175,9 @@ module Sequel
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
         end
+        if !c[:max_value] && !c[:min_value] && c[:type] == :integer && (min_max = column_schema_integer_min_max_values(c[:db_type]))
+          c[:min_value], c[:max_value] = min_max
+        end
       end
       schema_post_process(cols)
 
@@ -272,6 +275,40 @@ module Sequel
       column_schema_default_to_ruby_value(default, type) rescue nil
     end
 
+    INTEGER1_MIN_MAX = [-128, 127].freeze
+    INTEGER2_MIN_MAX = [-32768, 32767].freeze
+    INTEGER3_MIN_MAX = [-8388608, 8388607].freeze
+    INTEGER4_MIN_MAX = [-2147483648, 2147483647].freeze
+    INTEGER8_MIN_MAX = [-9223372036854775808, 9223372036854775807].freeze
+    UNSIGNED_INTEGER1_MIN_MAX = [0, 255].freeze
+    UNSIGNED_INTEGER2_MIN_MAX = [0, 65535].freeze
+    UNSIGNED_INTEGER3_MIN_MAX = [0, 16777215].freeze
+    UNSIGNED_INTEGER4_MIN_MAX = [0, 4294967295].freeze
+    UNSIGNED_INTEGER8_MIN_MAX = [0, 18446744073709551615].freeze
+
+    # Look at the db_type and guess the minimum and maximum integer values for
+    # the column.
+    def column_schema_integer_min_max_values(db_type)
+      unsigned = /unsigned/i =~ db_type
+      case db_type
+      when /big|int8/i
+        unsigned ? UNSIGNED_INTEGER8_MIN_MAX : INTEGER8_MIN_MAX
+      when /medium/i
+        unsigned ? UNSIGNED_INTEGER3_MIN_MAX : INTEGER3_MIN_MAX
+      when /small|int2/i
+        unsigned ? UNSIGNED_INTEGER2_MIN_MAX : INTEGER2_MIN_MAX
+      when /tiny/i
+        (unsigned || column_schema_tinyint_type_is_unsigned?) ? UNSIGNED_INTEGER1_MIN_MAX : INTEGER1_MIN_MAX
+      else
+        unsigned ? UNSIGNED_INTEGER4_MIN_MAX : INTEGER4_MIN_MAX
+      end
+    end
+
+    # Whether the tinyint type (if supported by the database) is unsigned by default.
+    def column_schema_tinyint_type_is_unsigned?
+      false
+    end
+
     # Look at the db_type and guess the maximum length of the column.
     # This assumes types such as varchar(255).
     def column_schema_max_length(db_type)

data/lib/sequel/dataset/actions.rb

@@ -313,14 +313,18 @@ module Sequel
     
     # Inserts multiple records into the associated table. This method can be
     # 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.
+    # single query if the database supports it. Inserts are automatically
+    # wrapped in a transaction if necessary.
     # 
     # This method is called with a columns array and an array of value arrays:
     #
     #   DB[:table].import([:x, :y], [[1, 2], [3, 4]])
     #   # INSERT INTO table (x, y) VALUES (1, 2) 
-    #   # INSERT INTO table (x, y) VALUES (3, 4) 
+    #   # INSERT INTO table (x, y) VALUES (3, 4)
+    #
+    # or, if the database supports it:
+    #
+    #   # INSERT INTO table (x, y) VALUES (1, 2), (3, 4)
     #
     # This method also accepts a dataset instead of an array of value arrays:
     #
@@ -328,9 +332,13 @@ module Sequel
     #   # INSERT INTO table (x, y) SELECT a, b FROM table2 
     #
     # Options:
-    # :commit_every :: Open a new transaction for every given number of records.
-    #                  For example, if you provide a value of 50, will commit
-    #                  after every 50 records.
+    # :commit_every :: Open a new transaction for every given number of
+    #                  records. For example, if you provide a value of 50,
+    #                  will commit after every 50 records. When a
+    #                  transaction is not required, this option controls
+    #                  the maximum number of values to insert with a single
+    #                  statement; it does not force the use of a
+    #                  transaction.
     # :return :: When this is set to :primary_key, returns an array of
     #            autoincremented primary key values for the rows inserted.
     #            This does not have an effect if +values+ is a Dataset.
@@ -576,7 +584,7 @@ module Sequel
     #   # SELECT * FROM table ORDER BY id LIMIT 1000 OFFSET 1000
     #   # ...
     #
-    #   DB[:table].order(:id).paged_each(:rows_per_fetch=>100){|row| }
+    #   DB[:table].order(:id).paged_each(rows_per_fetch: 100){|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 100
     #   # SELECT * FROM table ORDER BY id LIMIT 100 OFFSET 100
     #   # ...
@@ -1023,18 +1031,19 @@ module Sequel
 
     # Internals of #import.  If primary key values are requested, use
     # separate insert commands for each row.  Otherwise, call #multi_insert_sql
-    # and execute each statement it gives separately.
+    # and execute each statement it gives separately. A transaction is only used
+    # if there are multiple statements to execute.
     def _import(columns, values, opts)
       trans_opts = Hash[opts]
       trans_opts[:server] = @opts[:server]
       if opts[:return] == :primary_key
-        @db.transaction(trans_opts){values.map{|v| insert(columns, v)}}
+        _import_transaction(values, trans_opts){values.map{|v| insert(columns, v)}}
       else
         stmts = multi_insert_sql(columns, values)
-        @db.transaction(trans_opts){stmts.each{|st| execute_dui(st)}}
+        _import_transaction(stmts, trans_opts){stmts.each{|st| execute_dui(st)}}
       end
     end
-  
+
     # Return an array of arrays of values given by the symbols in ret_cols.
     def _select_map_multiple(ret_cols)
       map{|r| r.values_at(*ret_cols)}
@@ -1073,6 +1082,17 @@ module Sequel
       end
     end
     
+    # Use a transaction when yielding to the block if multiple values/statements
+    # are provided. When only a single value or statement is provided, then yield
+    # without using a transaction.
+    def _import_transaction(values, trans_opts, &block)
+      if values.length > 1
+        @db.transaction(trans_opts, &block)
+      else
+        yield
+      end
+    end
+  
     # Internals of +select_hash+ and +select_hash_groups+
     def _select_hash(meth, key_column, value_column, opts=OPTS)
       select(*(key_column.is_a?(Array) ? key_column : [key_column]) + (value_column.is_a?(Array) ? value_column : [value_column])).

data/lib/sequel/dataset/features.rb

@@ -152,6 +152,11 @@ module Sequel
       supports_distinct_on?
     end
     
+    # Whether placeholder literalizers are supported, true by default.
+    def supports_placeholder_literalizer?
+      true
+    end
+
     # Whether the dataset supports pattern matching by regular expressions, false by default.
     def supports_regexp?
       false

data/lib/sequel/dataset/misc.rb

@@ -302,7 +302,7 @@ module Sequel
           cache_set(key, loader + 1)
           loader = nil
         end
-      elsif cache_sql?
+      elsif cache_sql? && supports_placeholder_literalizer?
         cache_set(key, 1)
       end
 

data/lib/sequel/dataset/query.rb

@@ -65,7 +65,7 @@ module Sequel
       Sequel.synchronize{EXTENSIONS[ext] = block}
     end
 
-    # On Ruby 2.4+, use clone(:freeze=>false) to create clones, because
+    # On Ruby 2.4+, use clone(freeze: false) to create clones, because
     # we use true freezing in that case, and we need to modify the opts
     # in the frozen copy.
     #
@@ -116,7 +116,7 @@ module Sequel
     #  DB[:items].order(:id).distinct(:id) # SQL: SELECT DISTINCT ON (id) * FROM items ORDER BY id
     #  DB[:items].order(:id).distinct{func(:id)} # SQL: SELECT DISTINCT ON (func(id)) * FROM items ORDER BY id
     #
-    # There is support for emualting the DISTINCT ON support in MySQL, but it
+    # There is support for emulating the DISTINCT ON support in MySQL, but it
     # does not support the ORDER of the dataset, and also doesn't work in many
     # cases if the ONLY_FULL_GROUP_BY sql_mode is used, which is the default on
     # MySQL 5.7.5+.
@@ -787,7 +787,7 @@ module Sequel
     #   DB[:items].order(Sequel.lit('a + b')) # SELECT * FROM items ORDER BY a + b
     #   DB[:items].order(Sequel[:a] + :b) # SELECT * FROM items ORDER BY (a + b)
     #   DB[:items].order(Sequel.desc(:name)) # SELECT * FROM items ORDER BY name DESC
-    #   DB[:items].order(Sequel.asc(:name, :nulls=>:last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
+    #   DB[:items].order(Sequel.asc(:name, nulls: :last)) # SELECT * FROM items ORDER BY name ASC NULLS LAST
     #   DB[:items].order{sum(name).desc} # SELECT * FROM items ORDER BY sum(name) DESC
     #   DB[:items].order(nil) # SELECT * FROM items
     def order(*columns, &block)
@@ -857,13 +857,13 @@ module Sequel
     #   DB[:items].returning(nil) # RETURNING NULL
     #   DB[:items].returning(:id, :name) # RETURNING id, name
     #
-    #   DB[:items].returning.insert(:a=>1) do |hash|
+    #   DB[:items].returning.insert(a: 1) do |hash|
     #     # hash for each row inserted, with values for all columns
     #   end
-    #   DB[:items].returning.update(:a=>1) do |hash|
+    #   DB[:items].returning.update(a: 1) do |hash|
     #     # hash for each row updated, with values for all columns
     #   end
-    #   DB[:items].returning.delete(:a=>1) do |hash|
+    #   DB[:items].returning.delete(a: 1) do |hash|
     #     # hash for each row deleted, with values for all columns
     #   end
     def returning(*values)
@@ -1102,7 +1102,7 @@ module Sequel
     # referenced in window functions. See Sequel::SQL::Window for a list of
     # options that can be passed in. Example:
     #
-    #   DB[:items].window(:w, :partition=>:c1, :order=>:c2)
+    #   DB[:items].window(:w, partition: :c1, order: :c2)
     #   # SELECT * FROM items WINDOW w AS (PARTITION BY c1 ORDER BY c2)
     def window(name, opts)
       clone(:window=>((@opts[:window]||EMPTY_ARRAY) + [[name, SQL::Window.new(opts)].freeze]).freeze)
@@ -1163,7 +1163,7 @@ module Sequel
     #   DB[:t].with_recursive(:t,
     #     DB[:i1].select(:id, :parent_id).where(parent_id: nil),
     #     DB[:i1].join(:t, id: :parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]),
-    #     :args=>[:id, :parent_id])
+    #     args: [:id, :parent_id])
     #   
     #   # WITH RECURSIVE t(id, parent_id) AS (
     #   #   SELECT id, parent_id FROM i1 WHERE (parent_id IS NULL)
@@ -1241,7 +1241,7 @@ module Sequel
     #
     # You can also provide a method name and arguments to call to get the SQL:
     #
-    #   DB[:items].with_sql(:insert_sql, :b=>1) # INSERT INTO items (b) VALUES (1)
+    #   DB[:items].with_sql(:insert_sql, b: 1) # INSERT INTO items (b) VALUES (1)
     #
     # Note that datasets that specify custom SQL using this method will generally
     # ignore future dataset methods that modify the SQL used, as specifying custom SQL

data/lib/sequel/dataset/sql.rb

@@ -1725,7 +1725,7 @@ module Sequel
     # Append literalization of the subselect to SQL string.
     def subselect_sql_append(sql, ds)
       sds = subselect_sql_dataset(sql, ds)
-      sds.sql
+      subselect_sql_append_sql(sql, sds)
       unless sds.send(:cache_sql?)
         # If subquery dataset does not allow caching SQL,
         # then this dataset should not allow caching SQL.
@@ -1737,6 +1737,10 @@ module Sequel
       ds.clone(:append_sql=>sql)
     end
 
+    def subselect_sql_append_sql(sql, ds)
+      ds.sql
+    end
+
     # The number of decimal digits of precision to use in timestamps.
     def timestamp_precision
       supports_timestamp_usecs? ? 6 : 0

data/lib/sequel/extensions/_model_pg_row.rb

@@ -23,18 +23,6 @@ module Sequel
             super
           end
         end
-
-        private
-
-        # Handle Sequel::Model instances in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when Sequel::Model
-            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/sequel/extensions/_pretty_table.rb

@@ -39,7 +39,7 @@ module Sequel
 
     # Hash of the maximum size of the value for each column 
     def self.column_sizes(records, columns) # :nodoc:
-      sizes = Hash.new {0}
+      sizes = Hash.new(0)
       columns.each do |c|
         sizes[c] = c.to_s.size
       end

data/lib/sequel/extensions/async_thread_pool.rb

@@ -5,9 +5,9 @@
 # code
 #
 #   DB.extension :async_thread_pool
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where{name: 'A'..'M'}.all
 #   bar_names = DB[:bar].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #
 # All 3 queries will be run in separate threads.  +foos+, +bar_names+
 # and +baz_1+ will be proxy objects.  Calling a method on the proxy
@@ -15,9 +15,9 @@
 # of calling that method on the result of the query method. For example,
 # if you run:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where{name: 'A'..'M'}.all
 #   bar_names = DB[:bars].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #   sleep(1)
 #   foos.size
 #   bar_names.first
@@ -26,9 +26,9 @@
 # These three queries will generally be run concurrently in separate
 # threads.  If you instead run:
 #   
-#   DB[:foos].async.where{:name=>'A'..'M'}.all.size
+#   DB[:foos].async.where{name: 'A'..'M'}.all.size
 #   DB[:bars].async.select_order_map(:name).first
-#   DB[:bazes].async.first(:id=>1).name
+#   DB[:bazes].async.first(id: 1).name
 #
 # Then will run each query sequentially, since you need the result of
 # one query before running the next query.  The queries will still be
@@ -37,11 +37,11 @@
 # What is run in the separate thread is the entire method call that
 # returns results.  So with the original example:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where{name: 'A'..'M'}.all
 #   bar_names = DB[:bars].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #
-# The +all+, <tt>select_order_map(:name)</tt>, and <tt>first(:id=>1)</tt>
+# The +all+, <tt>select_order_map(:name)</tt>, and <tt>first(id: 1)</tt>
 # calls are run in separate threads.  If a block is passed to a method
 # such as +all+ or +each+, the block is also run in that thread.  If you
 # have code such as:
@@ -156,10 +156,10 @@
 # so that the query will run in the current thread instead of waiting
 # for an async thread to become available.  With the following code:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where{name: 'A'..'M'}.all
 #   bar_names = DB[:bar].async.select_order_map(:name)
 #   if foos.length > 4
-#     baz_1 = DB[:bazes].async.first(:id=>1)
+#     baz_1 = DB[:bazes].async.first(id: 1)
 #   end
 # 
 # Whether you need the +baz_1+ variable depends on the value of foos.

data/lib/sequel/extensions/auto_literal_strings.rb

@@ -22,7 +22,7 @@
 #
 # Named placeholders can also be used with a hash:
 #
-#   ds.where("name > :a", :a=>"A")
+#   ds.where("name > :a", a: "A")
 #   # SELECT * FROM table WHERE (name > 'A')
 #
 # This extension also allows the use of a plain string passed to Dataset#update:

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/date_arithmetic.rb

@@ -25,7 +25,7 @@
 # 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:

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

@@ -377,7 +377,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

data/lib/sequel/extensions/named_timezones.rb

@@ -76,33 +76,45 @@ module Sequel
         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)
+        # :nocov:
+        if defined?(JRUBY_VERSION)
+          Time.at(v.to_i - offset, :in => input_timezone) + v.nsec/1000000000.0
+        # :nocov:
+        else
+          Time.at(v.to_i - offset, v.nsec, :nsec, :in => input_timezone)
+        end
       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)
+        # :nocov:
+        if defined?(JRUBY_VERSION)
+          Time.at(v.to_i, :in => output_timezone) + v.nsec/1000000000.0
+        # :nocov:
+        else
+          Time.at(v.to_i, v.nsec, :nsec, :in => output_timezone)
+        end
       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
+        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0 
       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
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0 + 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
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0
         end
       end
       # :nodoc: