sequel 5.30.0 → 5.35.0

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

@@ -40,12 +40,22 @@ 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)
+
+          # :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)
+            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_json_ops.rb

@@ -554,7 +554,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]
@@ -304,6 +298,8 @@ module Sequel
       end
 
       module DatasetMethods
+        private
+
         # Handle literalization of ruby Range objects, treating them as
         # PostgreSQL ranges.
         def literal_other_append(sql, v)
@@ -469,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.

data/lib/sequel/extensions/pg_row.rb

@@ -222,7 +222,6 @@ module Sequel
         # Split the stored string into an array of strings, handling
         # the different types of quoting.
         def parse
-          return @result if @result
           values = []
           skip(/\(/)
           if skip(/\)/)

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 Sequel::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/s.rb

@@ -49,7 +49,9 @@ module Sequel::S
     Sequel.expr(*a, &block)
   end
 
+  # :nocov:
   if RUBY_VERSION >= '2.0.0'
+  # :nocov:
     refine Object do
       include Sequel::S
     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/extensions/symbol_aref_refinement.rb

@@ -25,7 +25,9 @@
 #
 # Related module: Sequel::SymbolAref
 
+# :nocov:
 raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
 
 module Sequel::SymbolAref
   refine Symbol do

data/lib/sequel/extensions/symbol_as_refinement.rb

@@ -23,7 +23,9 @@
 #
 # Related module: Sequel::SymbolAs
 
+# :nocov:
 raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
 
 module Sequel::SymbolAs
   refine Symbol do

data/lib/sequel/extensions/to_dot.rb

@@ -53,7 +53,13 @@ module Sequel
     # is given, it is used directly as the node or transition.  Otherwise
     # a node is created for the current object.
     def dot(label, j=nil)
-      @dot << "#{j||@i} [label=#{label.to_s.inspect}];"
+      label = case label
+      when nil
+        "<nil>"
+      else
+        label.to_s
+      end
+      @dot << "#{j||@i} [label=#{label.inspect}];"
     end
 
     # Recursive method that parses all of Sequel's internal datastructures,
@@ -61,7 +67,7 @@ module Sequel
     # structure.
     def v(e, l)
       @i += 1
-      dot(l, "#{@stack.last} -> #{@i}") if l
+      dot(l, "#{@stack.last} -> #{@i}")
       @stack.push(@i)
       case e
       when LiteralString
@@ -144,7 +150,7 @@ module Sequel
         dot "Dataset"
         TO_DOT_OPTIONS.each do |k|
           if val = e.opts[k]
-            v(val, k.to_s) 
+            v(val, k) 
           end
         end
       else

data/lib/sequel/model.rb

@@ -69,7 +69,9 @@ module Sequel
     require_relative "model/base"
     require_relative "model/exceptions"
     require_relative "model/errors"
+    # :nocov:
     if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
+    # :nocov:
       require_relative 'model/associations'
       plugin Model::Associations
     end

data/lib/sequel/model/associations.rb

@@ -164,11 +164,11 @@ module Sequel
         # range to return the object(s) at the correct offset/limit.
         def apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset())
           name = self[:name]
+          return unless range = slice_range(limit_and_offset)
           if returns_array?
-            range = slice_range(limit_and_offset)
             rows.each{|o| o.associations[name] = o.associations[name][range] || []}
-          elsif sr = slice_range(limit_and_offset)
-            offset = sr.begin
+          else
+            offset = range.begin
             rows.each{|o| o.associations[name] = o.associations[name][offset]}
           end
         end
@@ -356,7 +356,7 @@ module Sequel
         def finalize
           return unless cache = self[:cache]
 
-          finalize_settings.each do |meth, key|
+          finalizer = proc do |meth, key|
             next if has_key?(key)
 
             # Allow calling private methods to make sure caching is done appropriately
@@ -364,6 +364,13 @@ module Sequel
             self[key] = cache.delete(key) if cache.has_key?(key)
           end
 
+          finalize_settings.each(&finalizer)
+
+          unless self[:instance_specific]
+            finalizer.call(:associated_eager_dataset, :associated_eager_dataset)
+            finalizer.call(:filter_by_associations_conditions_dataset, :filter_by_associations_conditions_dataset)
+          end
+
           nil
         end
 
@@ -371,9 +378,7 @@ module Sequel
         FINALIZE_SETTINGS = {
           :associated_class=>:class,
           :associated_dataset=>:_dataset,
-          :associated_eager_dataset=>:associated_eager_dataset,
           :eager_limit_strategy=>:_eager_limit_strategy,
-          :filter_by_associations_conditions_dataset=>:filter_by_associations_conditions_dataset,
           :placeholder_loader=>:placeholder_loader,
           :predicate_key=>:predicate_key,
           :predicate_keys=>:predicate_keys,
@@ -432,7 +437,11 @@ module Sequel
           if use_placeholder_loader?
             cached_fetch(:placeholder_loader) do
               Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
-                ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
+                ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
+                if self[:block]
+                  ds = self[:block].call(ds)
+                end
+                ds
               end
             end
           end
@@ -796,7 +805,7 @@ module Sequel
 
         # Whether the placeholder loader can be used to load the association.
         def use_placeholder_loader?
-          !self[:instance_specific] && !self[:eager_graph]
+          self[:use_placeholder_loader]
         end
       end
     
@@ -1244,7 +1253,9 @@ module Sequel
             else
               assoc_record.values.delete(left_key_alias)
             end
-            next unless objects = h[hash_key]
+
+            objects = h[hash_key]
+
             if assign_singular
               objects.each do |object| 
                 object.associations[name] ||= assoc_record
@@ -1791,11 +1802,12 @@ module Sequel
           opts.merge!(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
 
           opts[:block] = block if block
-          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block] || orig_opts[:dataset])
+          opts[:instance_specific] = true if orig_opts[:dataset]
+          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block])
             # It's possible the association is instance specific, in that it depends on
             # values other than the foreign key value.  This needs to be checked for
             # in certain places to disable optimizations.
-            opts[:instance_specific] = true
+            opts[:instance_specific] = _association_instance_specific_default(name)
           end
           opts = assoc_class.new.merge!(opts)
 
@@ -1803,6 +1815,7 @@ module Sequel
             raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})")
           end
 
+          opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph]
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
           opts[:graph_join_type] ||= :left_outer
           opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
@@ -1899,6 +1912,12 @@ module Sequel
         Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
         private
+
+        # The default value for the instance_specific option, if the association
+        # could be instance specific and the :instance_specific option is not specified.
+        def _association_instance_specific_default(_)
+          true
+        end
       
         # The module to use for the association's methods.  Defaults to
         # the overridable_methods_module.
@@ -1948,10 +1967,8 @@ module Sequel
           if opts[:block]
             opts[:block_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_block", 1, &opts[:block])
           end
-          if opts[:dataset]
-            opts[:dataset_opt_arity] = opts[:dataset].arity == 0 ? 0 : 1
-            opts[:dataset_opt_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_dataset_opt", opts[:dataset_opt_arity], &opts[:dataset])
-          end
+          opts[:dataset_opt_arity] = opts[:dataset].arity == 0 ? 0 : 1
+          opts[:dataset_opt_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_dataset_opt", opts[:dataset_opt_arity], &opts[:dataset])
           def_association_method(opts)
 
           return if opts[:read_only]
@@ -2122,9 +2139,7 @@ module Sequel
 
             eager_load_results(opts, eo) do |assoc_record|
               hash_key = uses_cks ? pk_meths.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(opts.primary_key_method)
-              if objects = h[hash_key]
-                objects.each{|object| object.associations[name] = assoc_record}
-              end
+              h[hash_key].each{|object| object.associations[name] = assoc_record}
             end
           end
       
@@ -2171,7 +2186,7 @@ module Sequel
             eager_load_results(opts, eo) do |assoc_record|
               assoc_record.values.delete(delete_rn) if delete_rn
               hash_key = uses_cks ? km.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(km)
-              next unless objects = h[hash_key]
+              objects = h[hash_key]
               if assign_singular
                 objects.each do |object| 
                   unless object.associations[name]
@@ -2966,8 +2981,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 +2998,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
@@ -3056,6 +3079,8 @@ module Sequel
         #                    significantly slower in some cases (perhaps even the majority of cases), so you should
         #                    only use this if you have benchmarked that it is faster for your use cases.
         def eager_graph_with_options(associations, opts=OPTS)
+          return self if associations.empty?
+
           opts = opts.dup unless opts.frozen?
           associations = [associations] unless associations.is_a?(Array)
           ds = if eg = @opts[:eager_graph]
@@ -3125,11 +3150,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 +3182,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
@@ -3177,7 +3207,6 @@ module Sequel
         # requirements :: an array, used as a stack for requirements
         # *associations :: the associations to add to the graph
         def eager_graph_associations(ds, model, ta, requirements, *associations)
-          return ds if associations.empty?
           associations.flatten.each do |association|
             ds = case association
             when Symbol, SQL::AliasedExpression
@@ -3307,7 +3336,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