sequel 5.29.0 → 5.34.0

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.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
@@ -1244,7 +1244,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
@@ -1948,10 +1950,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 +2122,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 +2169,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 +2964,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 +2981,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 +3062,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 +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
@@ -3177,7 +3190,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 +3319,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

data/lib/sequel/model/base.rb

@@ -460,47 +460,6 @@ module Sequel
         super
       end
 
-      # If possible, set the dataset for the model subclass as soon as it
-      # is created.  Also, make sure the inherited class instance variables
-      # are copied into the subclass.
-      #
-      # Sequel queries the database to get schema information as soon as
-      # a model class is created:
-      #
-      #   class Artist < Sequel::Model # Causes schema query
-      #   end
-      def inherited(subclass)
-        super
-        ivs = subclass.instance_variables
-        inherited_instance_variables.each do |iv, dup|
-          next if ivs.include?(iv)
-          if (sup_class_value = instance_variable_get(iv)) && dup
-            sup_class_value = case dup
-            when :dup
-              sup_class_value.dup
-            when :hash_dup
-              h = {}
-              sup_class_value.each{|k,v| h[k] = v.dup}
-              h
-            when Proc
-              dup.call(sup_class_value)
-            else
-              raise Error, "bad inherited instance variable type: #{dup.inspect}"
-            end
-          end
-          subclass.instance_variable_set(iv, sup_class_value)
-        end
-
-        unless ivs.include?(:@dataset)
-          if @dataset && self != Model
-            subclass.set_dataset(@dataset.clone, :inherited=>true)
-          elsif (n = subclass.name) && !n.to_s.empty?
-            db
-            subclass.set_dataset(subclass.implicit_table_name)
-          end
-        end
-      end
-
       # Returns the implicit table name for the model class, which is the demodulized,
       # underscored, pluralized name of the class.
       #
@@ -515,12 +474,6 @@ module Sequel
         call(values)
       end
 
-      # Clear the setter_methods cache when a setter method is added.
-      def method_added(meth)
-        clear_setter_methods_cache if meth.to_s.end_with?('=')
-        super
-      end
-  
       # Mark the model as not having a primary key. Not having a primary key
       # can cause issues, among which is that you won't be able to update records.
       #
@@ -640,7 +593,7 @@ module Sequel
           @columns = superclass.instance_variable_get(:@columns)
           @db_schema = superclass.instance_variable_get(:@db_schema)
         else
-          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse) if @dataset_method_modules
+          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse)
           @db_schema = get_db_schema
         end
 
@@ -854,6 +807,46 @@ module Sequel
         meths
       end
   
+      # If possible, set the dataset for the model subclass as soon as it
+      # is created.  Also, make sure the inherited class instance variables
+      # are copied into the subclass.
+      #
+      # Sequel queries the database to get schema information as soon as
+      # a model class is created:
+      #
+      #   class Artist < Sequel::Model # Causes schema query
+      #   end
+      def inherited(subclass)
+        super
+        ivs = subclass.instance_variables
+        inherited_instance_variables.each do |iv, dup|
+          if (sup_class_value = instance_variable_get(iv)) && dup
+            sup_class_value = case dup
+            when :dup
+              sup_class_value.dup
+            when :hash_dup
+              h = {}
+              sup_class_value.each{|k,v| h[k] = v.dup}
+              h
+            when Proc
+              dup.call(sup_class_value)
+            else
+              raise Error, "bad inherited instance variable type: #{dup.inspect}"
+            end
+          end
+          subclass.instance_variable_set(iv, sup_class_value)
+        end
+
+        unless ivs.include?(:@dataset)
+          if @dataset && self != Model
+            subclass.set_dataset(@dataset.clone, :inherited=>true)
+          elsif (n = subclass.name) && !n.to_s.empty?
+            db
+            subclass.set_dataset(subclass.implicit_table_name)
+          end
+        end
+      end
+
       # A hash of instance variables to automatically set up in subclasses.
       # Keys are instance variable symbols, values should be:
       # nil :: Assign directly from superclass to subclass (frozen objects)
@@ -908,6 +901,12 @@ module Sequel
         opts[:class_name] ||= '::' + ((name || '').split("::")[0..-2] + [camelize(default)]).join('::')
       end
   
+      # Clear the setter_methods cache when a setter method is added.
+      def method_added(meth)
+        clear_setter_methods_cache if meth.to_s.end_with?('=')
+        super
+      end
+  
       # Module that the class includes that holds methods the class adds for column accessors and
       # associations so that the methods can be overridden with +super+.
       def overridable_methods_module
@@ -1116,7 +1115,7 @@ module Sequel
         when nil
           return false
         when Array
-          return false if pk.any?(&:nil?)
+          return false if pkv.any?(&:nil?)
         end
 
         (obj.class == model) && (obj.pk == pkv)
@@ -1718,6 +1717,7 @@ module Sequel
 
       # The values hash to use when inserting a new record.
       alias _insert_values values
+      private :_insert_values
       
       # Refresh using a particular dataset, used inside save to make sure the same server
       # is used for reading newly inserted values from the database
@@ -1772,14 +1772,12 @@ module Sequel
               before_update
               columns = opts[:columns]
               if columns.nil?
-                if opts[:changed]
-                  cc = changed_columns
-                  columns_updated = @values.reject{|k,v| !cc.include?(k)}
-                  cc.clear
+                columns_updated = if opts[:changed]
+                  _save_update_changed_colums_hash
                 else
-                  columns_updated = _save_update_all_columns_hash
-                  _clear_changed_columns(:update)
+                  _save_update_all_columns_hash
                 end
+                _clear_changed_columns(:update)
               else # update only the specified columns
                 columns = Array(columns)
                 columns_updated = @values.reject{|k, v| !columns.include?(k)}
@@ -1827,6 +1825,14 @@ module Sequel
         v
       end
 
+      # Return a hash of values used when saving changed columns of an
+      # existing object.  Defaults to all of the objects current values
+      # that are recorded as modified.
+      def _save_update_changed_colums_hash
+        cc = changed_columns
+        @values.reject{|k,v| !cc.include?(k)}
+      end
+
       # Validate the object if validating on save. Skips validation
       # completely (including validation hooks) if
       # skip_validation_on_save! has been called on the object,
@@ -1982,6 +1988,7 @@ module Sequel
 
       # Get the ruby class or classes related to the given column's type.
       def schema_type_class(column)
+        # SEQUEL6: Remove
         if (sch = db_schema[column]) && (type = sch[:type])
           db.schema_type_class(type)
         end
@@ -2225,7 +2232,9 @@ module Sequel
     plugin self
 
     singleton_class.send(:undef_method, :dup, :clone, :initialize_copy)
+    # :nocov:
     if RUBY_VERSION >= '1.9.3'
+    # :nocov:
       singleton_class.send(:undef_method, :initialize_clone, :initialize_dup)
     end
   end

data/lib/sequel/model/plugins.rb

@@ -40,6 +40,7 @@ module Sequel
       mod.send(:define_method, :inherited_instance_variables) do ||
         super().merge!(hash)
       end
+      mod.send(:private, :inherited_instance_variables)
     end
 
     # Add method to +mod+ that overrides set_dataset to call the method afterward.
@@ -148,9 +149,8 @@ module Sequel
       required_args = arity
       arity -= 1 if keyword == :required
 
-      if callable.is_a?(Proc) && !callable.lambda?
-        optional_args -= arity
-      end
+      # callable currently is always a non-lambda Proc
+      optional_args -= arity
 
       [required_args, optional_args, rest, keyword]
     end

data/lib/sequel/plugins/association_lazy_eager_option.rb

@@ -0,0 +1,66 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The association_lazy_eager_option plugin supports passing
+    # an +:eager+ option to an association method.  If the related
+    # association is already cached, the cached version will be
+    # returned.  If the association is not already cached, it will
+    # be loaded, and the value of the +:eager+ option will be used
+    # to perform an eager load of the given associations.
+    # the plural versions.
+    #
+    # With Sequel's default behavior, you can already perform an
+    # eager load when lazy loading using a block:
+    #
+    #   obj.association{|ds| ds.eager(:nested_association)}
+    #
+    # However, this will ignore any cached version.  In more
+    # complex software, the association may already be cached
+    # and have the nested association cached inside of it, and
+    # using this callback approach then requires 2 unnecessary
+    # queries. This plugin will not perform any queries if the
+    # association is already cached, preventing duplicate work.
+    # However, you should make sure that an already loaded
+    # association has the nested association already eagerly
+    # loaded.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support the :eager association
+    #   # method option (called before loading subclasses)
+    #   Sequel::Model.plugin :association_lazy_eager_option
+    #
+    #   # Make the Album class support the :eager association
+    #   # method option
+    #   Album.plugin :association_lazy_eager_option
+    module AssociationLazyEagerOption
+      module InstanceMethods
+        private
+
+        # Return a dataset for the association after applying any dynamic callback.
+        def _associated_dataset(opts, dynamic_opts)
+          ds = super
+
+          if eager = dynamic_opts[:eager]
+            ds = ds.eager(eager)
+          end
+
+          ds
+        end
+        
+        # A placeholder literalizer that can be used to load the association, or nil to not use one.
+        def _associated_object_loader(opts, dynamic_opts)
+          return if dynamic_opts[:eager]
+          super
+        end
+
+        # Whether to use a simple primary key lookup on the associated class when loading.
+        def load_with_primary_key_lookup?(opts, dynamic_opts)
+          return false if dynamic_opts[:eager]
+          super
+        end
+      end
+    end
+  end
+end