sequel 5.33.0 → 5.38.0

data/lib/sequel/database/transactions.rb

@@ -154,7 +154,7 @@ module Sequel
     #              Note that this should not be used unless the entire transaction
     #              block is idempotent, as otherwise it can cause non-idempotent
     #              behavior to execute multiple times.
-    # :rollback :: Can the set to :reraise to reraise any Sequel::Rollback exceptions
+    # :rollback :: Can be set to :reraise to reraise any Sequel::Rollback exceptions
     #              raised, or :always to always rollback even if no exceptions occur
     #              (useful for testing).
     # :server :: The server to use for the transaction. Set to :default, :read_only, or
@@ -205,6 +205,10 @@ module Sequel
             end
           end
 
+          if opts[:savepoint] && !supports_savepoints?
+            raise Sequel::InvalidOperation, "savepoints not supported on #{database_type}"
+          end
+
           if already_in_transaction?(conn, opts)
             if opts[:rollback] == :always && !opts.has_key?(:savepoint)
               if supports_savepoints? 
@@ -418,11 +422,10 @@ module Sequel
     end
 
     # Retrieve the savepoint hooks that should be run for the given
-    # connection and commit status.
+    # connection and commit status.  This expacts that you are
+    # already inside a savepoint when calling.
     def savepoint_hooks(conn, committed)
-      if in_savepoint?(conn)
-        _trans(conn)[:savepoints].last[committed ? :after_commit : :after_rollback]
-      end
+      _trans(conn)[:savepoints].last[committed ? :after_commit : :after_rollback]
     end
 
     # Retrieve the transaction hooks that should be run for the given

data/lib/sequel/dataset/actions.rb

@@ -607,14 +607,16 @@ module Sequel
     # as_hash, it accepts an optional :hash parameter, into which entries will
     # be merged. 
     #
-    #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
+    #   DB[:table].select_hash(:id, :name)
+    #   # SELECT id, name FROM table
     #   # => {1=>'a', 2=>'b', ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].select_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
-    #   # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
+    #   DB[:table].select_hash([:id, :foo], [:name, :bar])
+    #   # SELECT id, foo, name, bar FROM table
+    #   # => {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
     #
     # When using this method, you must be sure that each expression has an alias
     # that Sequel can determine.
@@ -626,14 +628,16 @@ module Sequel
     # Similar to to_hash_groups, but only selects the columns given.  Like to_hash_groups,
     # it accepts an optional :hash parameter, into which entries will be merged. 
     #
-    #   DB[:table].select_hash_groups(:name, :id) # SELECT id, name FROM table
+    #   DB[:table].select_hash_groups(:name, :id)
+    #   # SELECT id, name FROM table
     #   # => {'a'=>[1, 4, ...], 'b'=>[2, ...], ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].select_hash_groups([:first, :middle], [:last, :id]) # SELECT * FROM table
-    #   # {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
+    #   DB[:table].select_hash_groups([:first, :middle], [:last, :id])
+    #   # SELECT first, middle, last, id FROM table
+    #   # => {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
     #
     # When using this method, you must be sure that each expression has an alias
     # that Sequel can determine.

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -114,10 +114,8 @@ module Sequel
             prepared_sql << sql
             prepared_sql << "$#{prepared_args[i]}"
           end
-          if final_sql
-            frags << final_sql
-            prepared_sql << final_sql
-          end
+          frags << final_sql
+          prepared_sql << final_sql
 
           [prepared_sql, frags]
         end
@@ -213,9 +211,7 @@ module Sequel
           end
           ds.literal_append(s, v)
         end
-        if sql = @final_sql
-          s << sql
-        end
+        s << @final_sql
         s
       end
     end

data/lib/sequel/dataset/query.rb

@@ -81,7 +81,7 @@ module Sequel
       # If the options changed include options in COLUMN_CHANGE_OPTS, the cached
       # columns are deleted.  This method should generally not be called
       # directly by user code.
-      def clone(opts = (return self; nil))
+      def clone(opts = nil || (return self))
         # return self used above because clone is called by almost all
         # other query methods, and it is the fastest approach
         c = super(:freeze=>false)
@@ -330,16 +330,17 @@ module Sequel
     #   # SELECT * FROM a WHERE ((a LIKE '%foo%' ESCAPE '\') AND (b LIKE '%foo%' ESCAPE '\')
     #   #   AND (a LIKE '%bar%' ESCAPE '\') AND (b LIKE '%bar%' ESCAPE '\'))
     def grep(columns, patterns, opts=OPTS)
+      column_op = opts[:all_columns] ? :AND : :OR
       if opts[:all_patterns]
         conds = Array(patterns).map do |pat|
-          SQL::BooleanExpression.new(opts[:all_columns] ? :AND : :OR, *Array(columns).map{|c| SQL::StringExpression.like(c, pat, opts)})
+          SQL::BooleanExpression.new(column_op, *Array(columns).map{|c| SQL::StringExpression.like(c, pat, opts)})
         end
-        where(SQL::BooleanExpression.new(opts[:all_patterns] ? :AND : :OR, *conds))
+        where(SQL::BooleanExpression.new(:AND, *conds))
       else
         conds = Array(columns).map do |c|
           SQL::BooleanExpression.new(:OR, *Array(patterns).map{|pat| SQL::StringExpression.like(c, pat, opts)})
         end
-        where(SQL::BooleanExpression.new(opts[:all_columns] ? :AND : :OR, *conds))
+        where(SQL::BooleanExpression.new(column_op, *conds))
       end
     end
 

data/lib/sequel/deprecated.rb

@@ -39,7 +39,7 @@ module Sequel
     # Print the message and possibly backtrace to the output.
     def self.deprecate(method, instead=nil)
       return unless output
-      message = instead ? "#{method} is deprecated and will be removed in Sequel 5.1.  #{instead}." : method
+      message = instead ? "#{method} is deprecated and will be removed in Sequel 6.  #{instead}." : method
       message = "#{prefix}#{message}" if prefix
       output.puts(message)
       case b = backtrace_filter
@@ -60,7 +60,9 @@ module Sequel
     # If using ruby 2.3+, use Module#deprecate_constant to deprecate the constant,
     # otherwise do nothing as the ruby implementation does not support constant deprecation.
     def self.deprecate_constant(mod, constant)
+      # :nocov:
       if RUBY_VERSION > '2.3'
+      # :nocov:
         mod.deprecate_constant(constant)
       end
     end

data/lib/sequel/exceptions.rb

@@ -8,7 +8,9 @@ module Sequel
     # exception is held here.
     attr_accessor :wrapped_exception
 
+    # :nocov:
     if RUBY_VERSION >= '2.1'
+    # :nocov:
       # Returned the wrapped exception if one exists, otherwise use
       # ruby's default behavior.
       def cause

data/lib/sequel/extensions/_pretty_table.rb

@@ -41,8 +41,7 @@ module Sequel
     def self.column_sizes(records, columns) # :nodoc:
       sizes = Hash.new {0}
       columns.each do |c|
-        s = c.to_s.size
-        sizes[c] = s if s > sizes[c]
+        sizes[c] = c.to_s.size
       end
       records.each do |r|
         columns.each do |c|

data/lib/sequel/extensions/columns_introspection.rb

@@ -75,8 +75,7 @@ module Sequel
       when SQL::Identifier
         c.value.to_sym
       when SQL::QualifiedIdentifier
-        col = c.column
-        col.is_a?(SQL::Identifier) ? col.value.to_sym : col.to_sym
+        c.column.to_sym
       when SQL::AliasedExpression
         a = c.alias
         a.is_a?(SQL::Identifier) ? a.value.to_sym : a.to_sym

data/lib/sequel/extensions/core_refinements.rb

@@ -10,7 +10,9 @@
 #
 #   using Sequel::CoreRefinements
 
+# :nocov:
 raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
 
 module Sequel::CoreRefinements
   refine Array do

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -39,7 +39,9 @@
 
 module Sequel
   module DuplicateColumnsHandler
+    # :nocov:
     CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
+    # :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)

data/lib/sequel/extensions/migration.rb

@@ -68,6 +68,7 @@ module Sequel
       # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
     # This object responds to all methods the database responds to.
     def respond_to_missing?(meth, include_private)
@@ -329,7 +330,8 @@ 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:
@@ -518,7 +520,6 @@ module Sequel
     def initialize(db, directory, opts=OPTS)
       super
       @current = opts[:current] || current_migration_version
-      raise(Error, "No current version available") unless current
 
       latest_version = latest_migration_version
       @target = if opts[:target]
@@ -538,6 +539,11 @@ module Sequel
       end
 
       @direction = current < target ? :up : :down
+
+      if @direction == :down && @current >= @files.length
+        raise Migrator::Error, "Missing migration version(s) needed to migrate down to target version (current: #{current}, target: #{target})"
+      end
+
       @migrations = get_migrations
     end
 

data/lib/sequel/extensions/pg_array_ops.rb

@@ -157,7 +157,9 @@ module Sequel
         else
           Sequel.function(:hstore, self, wrap_array(arg))
         end
+        # :nocov:
         if Sequel.respond_to?(:hstore_op)
+        # :nocov:
           v = Sequel.hstore_op(v)
         end
         v
@@ -283,7 +285,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(PGArray)
+    # :nocov:
       class PGArray
         # Wrap the PGArray instance in an ArrayOp, allowing you to easily use
         # the PostgreSQL array functions and operators with literal arrays.

data/lib/sequel/extensions/pg_enum.rb

@@ -181,7 +181,9 @@ module Sequel
   end
 
   # support reversible create_enum statements if the migration extension is loaded
+  # :nocov:
   if defined?(MigrationReverser)
+  # :nocov:
     class MigrationReverser
       private
       def create_enum(name, _)

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -189,7 +189,7 @@ module Sequel
           if date < DATETIME_YEAR_1
             date <<= ((date.year) * 24 - 12)
             date = db.from_application_timestamp(date)
-            minutes = (date.is_a?(DateTime) ? date.offset * 1440 : date.utc_offset/60).to_i
+            minutes = (date.offset * 1440).to_i
             date.strftime("'%Y-%m-%d %H:%M:%S.%N#{format_timestamp_offset(*minutes.divmod(60))} BC'")
           else
             super

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -312,7 +312,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(HStore)
+    # :nocov:
       class HStore
         # Wrap the receiver in an HStoreOp so you can easily use the PostgreSQL
         # hstore functions and operators with it.

data/lib/sequel/extensions/pg_inet.rb

@@ -41,7 +41,9 @@ module Sequel
         db.instance_exec do
           extend_datasets(InetDatasetMethods)
 
+          # :nocov:
           if !defined?(SEQUEL_PG_VERSION_INTEGER) || SEQUEL_PG_VERSION_INTEGER >= 11300
+          # :nocov:
             # sequel_pg 1.13.0+ will use inet/cidr conversion procs, but doing so is
             # slower, so don't add the conversion procs if using sequel_pg 1.13.0+.
             meth = IPAddr.method(:new)

data/lib/sequel/extensions/pg_json_ops.rb

@@ -73,7 +73,10 @@
 #   j.pretty                  # jsonb_pretty(jsonb_column)
 #   j.set(%w'0 a', :h)        # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
 #
-# On PostgreSQL 12+ SQL/JSON functions and operators are supported:
+#   j.set_lax(%w'0 a', :h, false, 'raise_exception')
+#   # jsonb_set_lax(jsonb_column, ARRAY['0','a'], h, false, 'raise_exception')
+#
+# On PostgreSQL 12+ SQL/JSON path functions and operators are supported:
 #
 #   j.path_exists('$.foo')      # (jsonb_column @? '$.foo')
 #   j.path_match('$.foo')       # (jsonb_column @@ '$.foo')
@@ -84,7 +87,15 @@
 #   j.path_query_array('$.foo') # jsonb_path_query_array(jsonb_column, '$.foo')
 #   j.path_query_first('$.foo') # jsonb_path_query_first(jsonb_column, '$.foo')
 #
-# For the PostgreSQL 12+ SQL/JSON functions, one argument is required (+path+) and
+# On PostgreSQL 13+ timezone-aware SQL/JSON path functions and operators are supported:
+#
+#   j.path_exists_tz!('$.foo')     # jsonb_path_exists_tz(jsonb_column, '$.foo')
+#   j.path_match_tz!('$.foo')      # jsonb_path_match_tz(jsonb_column, '$.foo')
+#   j.path_query_tz('$.foo')       # jsonb_path_query_tz(jsonb_column, '$.foo')
+#   j.path_query_array_tz('$.foo') # jsonb_path_query_array_tz(jsonb_column, '$.foo')
+#   j.path_query_first_tz('$.foo') # jsonb_path_query_first_tz(jsonb_column, '$.foo')
+#
+# For the PostgreSQL 12+ SQL/JSON path functions, one argument is required (+path+) and
 # two more arguments are optional (+vars+ and +silent+).  +path+ specifies the JSON path.
 # +vars+ specifies a hash or a string in JSON format of named variables to be
 # substituted in +path+. +silent+ specifies whether errors are suppressed. By default,
@@ -402,6 +413,11 @@ module Sequel
         Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists, path, vars, silent))
       end
 
+      # The same as #path_exists!, except that timezone-aware conversions are used for date/time values.
+      def path_exists_tz!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists_tz, path, vars, silent))
+      end
+
       # Returns the first item of the result of JSON path predicate check for the json object.
       # Returns nil if the first item is not true or false.
       #
@@ -425,6 +441,11 @@ module Sequel
         Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match, path, vars, silent))
       end
 
+      # The same as #path_match!, except that timezone-aware conversions are used for date/time values.
+      def path_match_tz!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match_tz, path, vars, silent))
+      end
+
       # Returns a set of all jsonb values specified by the JSON path
       # for the json object.
       #
@@ -440,6 +461,11 @@ module Sequel
         _path_function(:jsonb_path_query, path, vars, silent)
       end
 
+      # The same as #path_query, except that timezone-aware conversions are used for date/time values.
+      def path_query_tz(path, vars=nil, silent=nil)
+        _path_function(:jsonb_path_query_tz, path, vars, silent)
+      end
+
       # Returns a jsonb array of all values specified by the JSON path
       # for the json object.
       #
@@ -455,6 +481,11 @@ module Sequel
         JSONBOp.new(_path_function(:jsonb_path_query_array, path, vars, silent))
       end
 
+      # The same as #path_query_array, except that timezone-aware conversions are used for date/time values.
+      def path_query_array_tz(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_array_tz, path, vars, silent))
+      end
+
       # Returns the first item of the result specified by the JSON path
       # for the json object.
       #
@@ -470,6 +501,11 @@ module Sequel
         JSONBOp.new(_path_function(:jsonb_path_query_first, path, vars, silent))
       end
 
+      # The same as #path_query_first, except that timezone-aware conversions are used for date/time values.
+      def path_query_first_tz(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_first_tz, path, vars, silent))
+      end
+
       # Return the receiver, since it is already a JSONBOp.
       def pg_jsonb
         self
@@ -492,6 +528,12 @@ module Sequel
         self.class.new(function(:set, wrap_input_array(path), wrap_input_jsonb(other), create_missing))
       end
 
+      # The same as #set, except if +other+ is +nil+, then behaves according to +null_value_treatment+,
+      # which can be one of 'raise_exception', 'use_json_null' (default), 'delete_key', or 'return_target'.
+      def set_lax(path, other, create_missing=true, null_value_treatment='use_json_null')
+        self.class.new(function(:set_lax, wrap_input_array(path), wrap_input_jsonb(other), create_missing, null_value_treatment))
+      end
+
       private
 
       # Internals of the jsonb SQL/JSON path functions.
@@ -554,7 +596,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(JSONArray)
+    # :nocov:
       class JSONArray
         # Wrap the JSONArray instance in an JSONOp, allowing you to easily use
         # the PostgreSQL json functions and operators with literal jsons.

data/lib/sequel/extensions/pg_range.rb

@@ -158,7 +158,7 @@ module Sequel
             procs = conversion_procs
             add_conversion_proc(3908, Parser.new("tsrange", procs[1114]))
             add_conversion_proc(3910, Parser.new("tstzrange", procs[1184]))
-            if defined?(PGArray::Creator)
+            if respond_to?(:register_array_type) && defined?(PGArray::Creator)
               add_conversion_proc(3909, PGArray::Creator.new("tsrange", procs[3908]))
               add_conversion_proc(3911, PGArray::Creator.new("tstzrange", procs[3910]))
             end
@@ -215,12 +215,6 @@ module Sequel
 
           db_type = db_type.to_s.dup.freeze
 
-          if converter = opts[:converter]
-            raise Error, "can't provide both a block and :converter option to register" if block
-          else
-            converter = block
-          end
-
           if soid
             raise Error, "can't provide both a converter and :subtype_oid option to register" if has_converter 
             raise Error, "no conversion proc for :subtype_oid=>#{soid.inspect} in conversion_procs" unless converter = conversion_procs[soid]
@@ -471,8 +465,10 @@ module Sequel
         return @range if @range
         raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty?
         raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin?
+        # :nocov:
         raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") if STARTLESS_RANGE_NOT_SUPPORTED && !self.begin
         raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end
+        # :nocov:
         @range = Range.new(self.begin, self.end, exclude_end?)
       end
 

data/lib/sequel/extensions/pg_range_ops.rb

@@ -116,7 +116,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(PGRange)
+    # :nocov:
       class PGRange
         # Wrap the PGRange instance in an RangeOp, allowing you to easily use
         # the PostgreSQL range functions and operators with literal ranges.