sequel 5.28.0 → 5.33.0

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

data/lib/sequel/database/schema_generator.rb

@@ -126,7 +126,7 @@ module Sequel
       # :on_update :: Specify the behavior of this column when being updated
       #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :primary_key :: Make the column as a single primary key column.  This should not
-      #                 be used if you have a single, nonautoincrementing primary key column
+      #                 be used if you want a single autoincrementing primary key column
       #                 (use the primary_key method in that case).
       # :primary_key_constraint_name :: The name to give the primary key constraint
       # :primary_key_deferrable :: Similar to :deferrable, but for the primary key constraint

data/lib/sequel/database/transactions.rb

@@ -142,7 +142,7 @@ module Sequel
     # :num_retries :: The number of times to retry if the :retry_on option is used.
     #                 The default is 5 times.  Can be set to nil to retry indefinitely,
     #                 but that is not recommended.
-    # :before_retry :: Proc to execute before rertrying if the :retry_on option is used.
+    # :before_retry :: Proc to execute before retrying if the :retry_on option is used.
     #                  Called with two arguments: the number of retry attempts (counting
     #                  the current one) and the error the last attempt failed with.
     # :prepare :: A string to use as the transaction identifier for a
@@ -178,19 +178,15 @@ module Sequel
       opts = Hash[opts]
       if retry_on = opts[:retry_on]
         tot_retries = opts.fetch(:num_retries, 5)
-        num_retries = 0 unless tot_retries.nil?
+        num_retries = 0
         begin
           opts[:retry_on] = nil
           opts[:retrying] = true
           transaction(opts, &block)
         rescue *retry_on => e
-          if num_retries
-            num_retries += 1
-            if num_retries <= tot_retries
-              opts[:before_retry].call(num_retries, e) if opts[:before_retry]
-              retry
-            end
-          else
+          num_retries += 1
+          if tot_retries.nil? || num_retries <= tot_retries
+            opts[:before_retry].call(num_retries, e) if opts[:before_retry]
             retry
           end
           raise
@@ -439,13 +435,12 @@ module Sequel
 
     # Remove the current thread from the list of active transactions
     def remove_transaction(conn, committed)
+      callbacks = transaction_hooks(conn, committed)
       if in_savepoint?(conn)
         savepoint_callbacks = savepoint_hooks(conn, committed)
         if committed
           savepoint_rollback_callbacks = savepoint_hooks(conn, false)
         end
-      else
-        callbacks = transaction_hooks(conn, committed)
       end
 
       if transaction_finished?(conn)
@@ -453,7 +448,6 @@ module Sequel
         rolled_back = !committed
         Sequel.synchronize{h[:rolled_back] = rolled_back}
         Sequel.synchronize{@transactions.delete(conn)}
-        callbacks.each(&:call) if callbacks
       elsif savepoint_callbacks || savepoint_rollback_callbacks
         if committed
           meth = in_savepoint?(conn) ? :add_savepoint_hook : :add_transaction_hook 
@@ -473,6 +467,8 @@ module Sequel
           savepoint_callbacks.each(&:call)
         end
       end
+
+      callbacks.each(&:call) if callbacks
     end
 
     # SQL to rollback to a savepoint

data/lib/sequel/dataset/misc.rb

@@ -329,7 +329,7 @@ module Sequel
     end
 
     # Set the db, opts, and cache for the copy of the dataset.
-    def initialize_copy(c)
+    def initialize_clone(c, _=nil)
       @db = c.db
       @opts = Hash[c.opts]
       if cols = c.cache_get(:_columns)
@@ -338,7 +338,7 @@ module Sequel
         @cache = {}
       end
     end
-    alias initialize_clone initialize_copy
+    alias initialize_copy initialize_clone
 
     # Internal recursive version of unqualified_column_for, handling Strings inside
     # of other objects.

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/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

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[]'

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.
 #

data/lib/sequel/extensions/pg_inet.rb

@@ -40,12 +40,20 @@ module Sequel
       def self.extended(db)
         db.instance_exec do
           extend_datasets(InetDatasetMethods)
-          meth = IPAddr.method(:new)
-          add_conversion_proc(869, meth)
-          add_conversion_proc(650, meth)
+
+          if !defined?(SEQUEL_PG_VERSION_INTEGER) || SEQUEL_PG_VERSION_INTEGER >= 11300
+            # 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)
+            add_conversion_proc(869, meth)
+            add_conversion_proc(650, meth)
+            if respond_to?(:register_array_type)
+              register_array_type('inet', :oid=>1041, :scalar_oid=>869)
+              register_array_type('cidr', :oid=>651, :scalar_oid=>650)
+            end
+          end
+
           if respond_to?(:register_array_type)
-            register_array_type('inet', :oid=>1041, :scalar_oid=>869)
-            register_array_type('cidr', :oid=>651, :scalar_oid=>650)
             register_array_type('macaddr', :oid=>1040, :scalar_oid=>829)
           end
           @schema_type_classes[:ipaddr] = IPAddr

data/lib/sequel/extensions/pg_interval.rb

@@ -178,6 +178,8 @@ module Sequel
     end
 
     module IntervalDatasetMethods
+      private
+
       # Handle literalization of ActiveSupport::Duration objects, treating them as
       # PostgreSQL intervals.
       def literal_other_append(sql, v)

data/lib/sequel/extensions/pg_range.rb

@@ -304,6 +304,8 @@ module Sequel
       end
 
       module DatasetMethods
+        private
+
         # Handle literalization of ruby Range objects, treating them as
         # PostgreSQL ranges.
         def literal_other_append(sql, v)

data/lib/sequel/extensions/pg_timestamptz.rb

@@ -15,6 +15,8 @@
 module Sequel
   module Postgres
     module Timestamptz
+      private
+
       # Use timestamptz by default for generic timestamp value.
       def type_literal_generic_datetime(column)
         :timestamptz

data/lib/sequel/extensions/run_transaction_hooks.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+#
+# The run_transaction_hooks extension allows for running after_commit or
+# after_rollback extensions before commit or rollback.  It then removes
+# the hook after running it, so it will not be run twice.
+#
+# This extension should only be used in transactional tests where the
+# transaction always rolls back, to test the behavior of the after_commit
+# and after_rollback hooks.  Any other usage is probably a bad idea.
+#
+# Example:
+#
+#   DB.extension :run_transaction_hooks
+#   x = 1
+#   DB.transaction(rollback: :always) do
+#     DB.after_rollback{x = 3}
+#     DB.after_commit{x = 2}
+#
+#     x # => 1
+#     DB.run_after_rollback_hooks
+#     x # => 3
+#     DB.run_after_commit_hooks
+#     x # => 2
+#   end
+#   x # => 2
+
+#
+class Sequel::Database
+  module RunTransactionHooks
+    # Run all savepoint and transaction after_commit hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_commit_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_commit, opts)
+    end
+
+    # Run all savepoint and transaction after_rollback hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_rollback_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_rollback, opts)
+    end
+
+    private
+
+    def _run_transaction_hooks(type, opts)
+      synchronize(opts[:server]) do |conn|
+        unless h = _trans(conn)
+          raise Error, "Cannot call run_#{type}_hooks outside of a transaction"
+        end
+
+        if hooks = h[type]
+          hooks.each(&:call)
+          hooks.clear
+        end
+
+        if (savepoints = h[:savepoints])
+          savepoints.each do |savepoint|
+            if hooks = savepoint[type]
+              hooks.each(&:call)
+              hooks.clear
+            end
+          end
+        end
+      end
+    end
+  end
+
+  register_extension(:run_transaction_hooks, RunTransactionHooks)
+end

data/lib/sequel/extensions/schema_dumper.rb

@@ -199,12 +199,18 @@ END_MIG
         end
         type = col_opts.delete(:type)
         col_opts.delete(:size) if col_opts[:size].nil?
-        col_opts[:default] = if schema[:ruby_default].nil?
-          column_schema_to_ruby_default_fallback(schema[:default], options)
+        if schema[:generated]
+          if options[:same_db] && database_type == :postgres
+            col_opts[:generated_always_as] = column_schema_to_ruby_default_fallback(schema[:default], options)
+          end
         else
-          schema[:ruby_default]
+          col_opts[:default] = if schema[:ruby_default].nil?
+            column_schema_to_ruby_default_fallback(schema[:default], options)
+          else
+            schema[:ruby_default]
+          end
+          col_opts.delete(:default) if col_opts[:default].nil?
         end
-        col_opts.delete(:default) if col_opts[:default].nil?
         col_opts[:null] = false if schema[:allow_null] == false
         if table = schema[:table]
           [:key, :on_delete, :on_update, :deferrable].each{|f| col_opts[f] = schema[f] if schema[f]}

data/lib/sequel/extensions/server_block.rb

@@ -143,13 +143,13 @@ module Sequel
 
     # Make the given server the new default server for the current thread.
     def set_default_server(default_server, read_only_server=default_server)
-      sync{(@default_servers[Thread.current] ||= [])} << [default_server, read_only_server]
+      sync{(@default_servers[Sequel.current] ||= [])} << [default_server, read_only_server]
     end
 
     # Remove the current default server for the current thread, restoring the
     # previous default server.
     def clear_default_server
-      t = Thread.current
+      t = Sequel.current
       a = sync{@default_servers[t]}
       a.pop
       sync{@default_servers.delete(t)} if a.empty?
@@ -157,7 +157,7 @@ module Sequel
 
     # Use the server given to with_server for the given thread, if appropriate.
     def pick_server(server)
-      a = sync{@default_servers[Thread.current]}
+      a = sync{@default_servers[Sequel.current]}
       if !a || a.empty?
         super
       else

data/lib/sequel/model/associations.rb

@@ -2966,8 +2966,8 @@ module Sequel
         # dataset.  If that association also has dependent associations, instead of a callable object,
         # use a hash with the callable object being the key, and the dependent association(s) as the value.
         # 
-        # You can specify an alias by providing a Sequel::SQL::AliasedExpression object instead of
-        # an a Symbol for the assocation name.
+        # You can specify an custom alias and/or join type on a per-association basis by providing an
+        # Sequel::SQL::AliasedExpression object instead of an a Symbol for the association name.
         #
         # Examples:
         #
@@ -2983,6 +2983,14 @@ module Sequel
         #   # FROM albums
         #   # LEFT OUTER JOIN artists AS a ON (a.id = albums.artist_id)
         #
+        #   # For each album, eager_graph load the artist, using a specified alias
+        #   # and custom join type
+        #
+        #   Album.eager_graph(Sequel[:artist].as(:a, join_type: :inner)).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # INNER JOIN artists AS a ON (a.id = albums.artist_id)
+        #
         #   # For each album, eager_graph load the artist and genre
         #   Album.eager_graph(:artist, :genre).all
         #   Album.eager_graph(:artist).eager_graph(:genre).all
@@ -3125,11 +3133,16 @@ module Sequel
         # ta :: table_alias used for the parent association
         # requirements :: an array, used as a stack for requirements
         # r :: association reflection for the current association, or an SQL::AliasedExpression
-        #      with the reflection as the expression and the alias base as the aliaz.
+        #      with the reflection as the expression, the alias base as the alias (or nil to
+        #      use the default alias), and an optional hash with a :join_type entry as the columns
+        #      to use a custom join type.
         # *associations :: any associations dependent on this one
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
           if r.is_a?(SQL::AliasedExpression)
             alias_base = r.alias
+            if r.columns.is_a?(Hash)
+              join_type = r.columns[:join_type]
+            end
             r = r.expression
           else
             alias_base = r[:graph_alias_base]
@@ -3152,7 +3165,7 @@ module Sequel
             raise Error, "Cannot eager_graph association when :conditions specified and not a hash or an array of pairs.  Specify :graph_conditions, :graph_only_conditions, or :graph_block for the association.  Model: #{r[:model]}, association: #{r[:name]}"
           end
 
-          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
+          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>join_type || local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
           if r[:order_eager_graph] && (order = r.fetch(:graph_order, r[:order]))
             ds = ds.order_append(*qualified_expression(order, assoc_table_alias))
           end
@@ -3307,7 +3320,7 @@ module Sequel
               end
             end
 
-            SQL::AliasedExpression.new(check_association(model, expr), association.alias)
+            SQL::AliasedExpression.new(check_association(model, expr), association.alias || expr, association.columns)
           else
             check_association(model, association)
           end