sequel 5.30.0 → 5.35.0

data/lib/sequel/database/connecting.rb

@@ -36,7 +36,7 @@ module Sequel
           c = adapter_class(scheme)
           uri_options = c.send(:uri_to_options, uri)
           uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
-          uri_options.to_a.each{|k,v| uri_options[k] = (defined?(URI::DEFAULT_PARSER) ? URI::DEFAULT_PARSER : URI).unescape(v) if v.is_a?(String)}
+          uri_options.to_a.each{|k,v| uri_options[k] = URI::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
           opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash

data/lib/sequel/database/misc.rb

@@ -153,19 +153,23 @@ module Sequel
       reset_default_dataset
       adapter_initialize
 
-      unless typecast_value_boolean(@opts[:keep_reference]) == false
-        Sequel.synchronize{::Sequel::DATABASES.push(self)}
-      end
-      Sequel::Database.run_after_initialize(self)
+      keep_reference = typecast_value_boolean(@opts[:keep_reference]) != false
+      begin
+        Sequel.synchronize{::Sequel::DATABASES.push(self)} if keep_reference
+        Sequel::Database.run_after_initialize(self)
 
-      initialize_load_extensions(:preconnect_extensions)
+        initialize_load_extensions(:preconnect_extensions)
 
-      if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
-        concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
-        @pool.send(:preconnect, concurrent)
-      end
+        if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
+          concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
+          @pool.send(:preconnect, concurrent)
+        end
 
-      initialize_load_extensions(:extensions)
+        initialize_load_extensions(:extensions)
+      rescue
+        Sequel.synchronize{::Sequel::DATABASES.delete(self)} if keep_reference
+        raise
+      end
     end
 
     # Freeze internal data structures for the Database instance.
@@ -185,7 +189,9 @@ module Sequel
 
     # Disallow dup/clone for Database instances
     undef_method :dup, :clone, :initialize_copy
+    # :nocov:
     if RUBY_VERSION >= '1.9.3'
+    # :nocov:
       undef_method :initialize_clone, :initialize_dup
     end
 

data/lib/sequel/database/query.rb

@@ -325,7 +325,7 @@ module Sequel
         :integer
       when /\Adate\z/io
         :date
-      when /\A((small)?datetime|timestamp( with(out)? time zone)?)(\(\d+\))?\z/io
+      when /\A((small)?datetime|timestamp(\(\d\))?( with(out)? time zone)?)\z/io
         :datetime
       when /\Atime( with(out)? time zone)?\z/io
         :time
@@ -344,7 +344,9 @@ module Sequel
 
     # Post process the schema values.  
     def schema_post_process(cols)
+      # :nocov:
       if RUBY_VERSION >= '2.5'
+      # :nocov:
         cols.each do |_, h|
           db_type = h[:db_type]
           if db_type.is_a?(String)

data/lib/sequel/database/schema_generator.rb

@@ -38,7 +38,6 @@ module Sequel
         @constraints = []
         @primary_key = nil
         instance_exec(&block) if block
-        @columns.unshift(@primary_key) if @primary_key && !has_column?(primary_key_name)
       end
 
       # Use custom Bignum method to use :Bignum instead of Bignum class, to work

data/lib/sequel/database/schema_methods.rb

@@ -494,7 +494,9 @@ module Sequel
       when :drop_index
         drop_index_sql(table, op)
       else
-        "ALTER TABLE #{quote_schema_table(table)} #{alter_table_op_sql(table, op)}"
+        if sql = alter_table_op_sql(table, op)
+          "ALTER TABLE #{quote_schema_table(table)} #{sql}"
+        end
       end
     end
 
@@ -811,23 +813,20 @@ module Sequel
     # Proxy the filter_expr call to the dataset, used for creating constraints.
     # Support passing Proc arguments as blocks, as well as treating plain strings
     # as literal strings, so that previous migrations that used this API do not break.
-    def filter_expr(*args, &block)
-      if args.length == 1
-        arg = args.first
-        if arg.is_a?(Proc) && !block
-          block = args.first
-          args = nil
-        elsif arg.is_a?(String)
-          args = [Sequel.lit(*args)]
-        elsif arg.is_a?(Array)
-          if arg.first.is_a?(String)
-            args = [Sequel.lit(*arg)]
-          elsif arg.length > 1
-            args = [Sequel.&(*arg)]
-          end
+    def filter_expr(arg=nil, &block)
+      if arg.is_a?(Proc) && !block
+        block = arg
+        arg = nil
+      elsif arg.is_a?(String)
+        arg = Sequel.lit(arg)
+      elsif arg.is_a?(Array)
+        if arg.first.is_a?(String)
+          arg = Sequel.lit(*arg)
+        elsif arg.length > 1
+          arg = Sequel.&(*arg)
         end
       end
-      schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))
+      schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, arg, &block))
     end
 
     # SQL statement for creating an index for the table with the given name

data/lib/sequel/database/transactions.rb

@@ -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/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/connection_expiration.rb

@@ -80,9 +80,9 @@ module Sequel
            Sequel.elapsed_seconds_since(cet[0]) > cet[1]
 
           if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Thread.current)}
+            sync{allocated(a.last).delete(Sequel.current)}
           else
-            sync{@allocated.delete(Thread.current)}
+            sync{@allocated.delete(Sequel.current)}
           end
 
           disconnect_connection(conn)

data/lib/sequel/extensions/connection_validator.rb

@@ -104,9 +104,9 @@ module Sequel
            !db.valid_connection?(conn)
 
           if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Thread.current)}
+            sync{allocated(a.last).delete(Sequel.current)}
           else
-            sync{@allocated.delete(Thread.current)}
+            sync{@allocated.delete(Sequel.current)}
           end
 
           disconnect_connection(conn)

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

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+#
+# The fiber_concurrency extension changes the default concurrency
+# primitive in Sequel to be Fiber.current instead of Thread.current.
+# This is the value used in various hash keys to implement safe
+# concurrency (thread-safe concurrency by default, fiber-safe
+# concurrency with this extension.  It can be enabled via:
+#
+#   Sequel.extension :fiber_concurrency
+#   
+# Related module: Sequel::FiberConcurrency
+
+require 'fiber'
+
+module Sequel
+  module FiberConcurrency
+    # Make the current concurrency primitive be Fiber.current.
+    def current
+      Fiber.current
+    end
+  end
+
+  extend FiberConcurrency
+end

data/lib/sequel/extensions/index_caching.rb

@@ -54,13 +54,6 @@ module Sequel
       db.instance_variable_set(:@indexes, {})
     end
     
-    # Remove the index cache for the given schema name
-    def remove_cached_schema(table)
-      k = quote_schema_table(table)
-      Sequel.synchronize{@indexes.delete(k)}
-      super
-    end
-    
     # Dump the index cache to the filename given in Marshal format.
     def dump_index_cache(file)
       File.open(file, 'wb'){|f| f.write(Marshal.dump(@indexes))}
@@ -101,6 +94,15 @@ module Sequel
       Sequel.synchronize{@indexes[quoted_name] = result}
       result
     end
+
+    private
+
+    # Remove the index cache for the given schema name
+    def remove_cached_schema(table)
+      k = quote_schema_table(table)
+      Sequel.synchronize{@indexes.delete(k)}
+      super
+    end
   end
 
   Database.register_extension(:index_caching, IndexCaching)

data/lib/sequel/extensions/integer64.rb

@@ -20,6 +20,8 @@
 #
 module Sequel
   module Integer64
+    private
+
     # Use same type as used for :Bignum by default for generic integer value.
     def type_literal_generic_integer(column)
       type_literal_generic_bignum_symbol(column)

data/lib/sequel/extensions/migration.rb

@@ -176,7 +176,7 @@ module Sequel
         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
@@ -518,7 +518,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]

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

@@ -40,8 +40,11 @@
 #   DB.schema(:table_name)
 #   [[:column_name, {:type=>:enum, :enum_values=>['value1', 'value2']}]]
 #
-# If the pg_array extension is used, arrays of enums are returned as a
-# PGArray:
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of enum types, load the pg_array extension before the
+# pg_interval extension:
+#
+#   DB.extension :pg_array, :pg_enum
 #
 #   DB.create_table(:table_name) do
 #     column :column_name, 'enum_type_name[]'
@@ -178,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.rb

@@ -74,6 +74,12 @@
 #
 #   DB.extension :pg_hstore
 #
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of hstore types, load the pg_array extension before the
+# pg_interval extension:
+#
+#   DB.extension :pg_array, :pg_hstore
+#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using hstore columns in CREATE/ALTER TABLE statements.
 #