sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/dataset_associations.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # DatasetAssociations allows you to easily use your model associations
@@ -10,7 +12,7 @@ module Sequel
     #     plugin :dataset_associations
     #     one_to_many :albums
     #   end
-    #   Artist.filter(id=>1..100).albums
+    #   Artist.where(id: 1..100).albums
     #   # SELECT * FROM albums
     #   # WHERE (albums.artist_id IN (
     #   #   SELECT id FROM artists
@@ -25,7 +27,7 @@ module Sequel
     # As the dataset methods return datasets, you can easily chain the
     # methods to get associated datasets of associated datasets:
     #
-    #   Artist.filter(id=>1..100).albums.filter{name < 'M'}.tags
+    #   Artist.where(id: 1..100).albums.where{name < 'M'}.tags
     #   # SELECT tags.* FROM tags
     #   # WHERE (tags.id IN (
     #   #   SELECT albums_tags.tag_id FROM albums
@@ -37,6 +39,14 @@ module Sequel
     #   #       WHERE ((id >= 1) AND (id <= 100)))
     #   #     AND
     #   #     (name < 'M')))))
+    #
+    # For associations that do JOINs, such as many_to_many, note that the datasets returned
+    # by a dataset association method do not do a JOIN by default (they use a subquery that
+    # JOINs).  This can cause problems when you are doing a select, order, or filter on a
+    # column in the joined table.  In that case, you should use the +:dataset_associations_join+
+    # option in the association, which will make sure the datasets returned by the dataset
+    # association methods also use JOINs, allowing such dataset association methods to work
+    # correctly.
     # 
     # Usage:
     #
@@ -52,7 +62,7 @@ module Sequel
           ret = super
           r = association_reflection(name)
           meth = r.returns_array? ? name : pluralize(name).to_sym
-          def_dataset_method(meth){associated(name)}
+          dataset_module{define_method(meth){associated(name)}}
           ret
         end
 
@@ -73,33 +83,65 @@ module Sequel
           sds = opts[:limit] ? self : unordered
           ds = case r[:type]
           when :many_to_one
-            ds.filter(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))
+            ds.where(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))
           when :one_to_one, :one_to_many
-            r.send(:apply_filter_by_associations_limit_strategy, ds.filter(r.qualified_key=>sds.select(*Array(r.qualified_primary_key))))
+            r.send(:apply_filter_by_associations_limit_strategy, ds.where(r.qualified_key=>sds.select(*Array(r.qualified_primary_key))))
           when :many_to_many, :one_through_one
             mds = r.associated_class.dataset.
               join(r[:join_table], r[:right_keys].zip(r.right_primary_keys)).
               select(*Array(r.qualified_right_key)).
               where(r.qualify(r.join_table_alias, r[:left_keys])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
-            ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
+            ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :many_through_many, :one_through_many
-            fre = r.reverse_edges.first
-            fe, *edges = r.edges
-            edges << r.final_edge
-            mds = model.
-              select(*Array(r.qualify(fre[:table], fre[:left]))).
-              join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name).
-              where(r.qualify(fe[:table], fe[:right])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
-            edges.each{|e| mds = mds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
-            ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
+            if r.reverse_edges.empty?
+              mds = r.associated_dataset
+              fe = r.edges.first
+              selection = Array(r.qualify(fe[:table], r.final_edge[:left]))
+              predicate_key = r.qualify(fe[:table], fe[:right])
+            else
+              mds = model.dataset
+              iq = model.table_name
+              edges = r.edges.map(&:dup)
+              edges << r.final_edge.dup
+              edges.each do |e|
+                alias_expr = e[:table]
+                aliaz = mds.unused_table_alias(e[:table])
+                unless aliaz == alias_expr
+                  alias_expr = Sequel.as(e[:table], aliaz)
+                end
+                e[:alias] = aliaz
+                mds = mds.join(alias_expr, Array(e[:right]).zip(Array(e[:left])), :implicit_qualifier=>iq)
+                iq = nil
+              end
+              fe, f1e, f2e = edges.values_at(0, -1, -2)
+              selection = Array(r.qualify(f2e[:alias], f1e[:left]))
+              predicate_key = r.qualify(fe[:alias], fe[:right])
+            end
+
+            mds = mds.
+              select(*selection).
+              where(predicate_key=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
+            ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :pg_array_to_many
-            ds.filter(Sequel.expr(r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}))
+            ds.where(Sequel[r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}])
           when :many_to_pg_array
-            ds.filter(Sequel.function(:coalesce, Sequel.pg_array_op(r[:key]).overlaps(sds.select{array_agg(r.qualify(r[:model].table_name, r.primary_key))}), false))
+            ds.where(Sequel.function(:coalesce, Sequel.pg_array_op(r[:key]).overlaps(sds.select{array_agg(r.qualify(r[:model].table_name, r.primary_key))}), false))
           else
             raise Error, "unrecognized association type for association #{name.inspect}: #{r[:type].inspect}"
           end
-          r.apply_eager_dataset_changes(ds).unlimited
+
+          ds = r.apply_eager_dataset_changes(ds).unlimited
+
+          if r[:dataset_associations_join]
+            case r[:type]
+            when :many_to_many, :one_through_one
+              ds = ds.join(r[:join_table], r[:right_keys].zip(r.right_primary_keys))
+            when :many_through_many, :one_through_many
+              (r.reverse_edges + [r.final_reverse_edge]).each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:left]).zip(Array(e[:right])) + Array(e[:conditions]))), :table_alias=>ds.unused_table_alias(e[:table]), :qualify=>:deep, &e[:block])}
+            end
+          end
+
+          ds
         end
       end
     end

data/lib/sequel/plugins/def_dataset_method.rb

@@ -0,0 +1,90 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The def_dataset_method plugin adds Model.def_dataset_method
+    # for defining dataset methods:
+    #
+    #   Album.def_dataset_method(:by_name) do |name|
+    #     where(name: name)
+    #   end
+    #
+    # Additionally, this adds support for Model.subset, which can also
+    # be used to define dataset methods that add specific filters:
+    #
+    #   Album.subset(:gold){copies_sold >= 500000}
+    #
+    # This exists for backwards compatibility with previous Sequel versions.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support Model.def_dataset_method
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :def_dataset_method
+    #
+    #   # Make the Album class support Model.def_dataset_method
+    #   Album.plugin :def_dataset_method
+    module DefDatasetMethod
+      module ClassMethods
+        # If a block is given, define a method on the dataset (if the model currently has an dataset)  with the given argument name using
+        # the given block.  Also define a class method on the model that calls the
+        # dataset method.  Stores the method name and block so that it can be reapplied if the model's
+        # dataset changes.
+        #
+        # If a block is not given, just define a class method on the model for each argument
+        # that calls the dataset method of the same argument name.
+        #
+        # Using dataset_module is recommended over using this method.  In addition to allowing
+        # more natural ruby syntax for defining methods manually, it also offers numerous
+        # helper methods that make defining common dataset methods more easily, as well as
+        # supporting dataset caching (assuming the arguments allow it).
+        #
+        #   # Add new dataset method and class method that calls it
+        #   Artist.def_dataset_method(:by_name){order(:name)}
+        #   Artist.where(Sequel[:name].like('A%')).by_name
+        #   Artist.by_name.where(Sequel[:name].like('A%'))
+        #
+        #   # Just add a class method that calls an existing dataset method
+        #   Artist.def_dataset_method(:paginate)
+        #   Artist.paginate(2, 10)
+        def def_dataset_method(*args, &block)
+          raise(Error, "No arguments given") if args.empty?
+
+          if block
+            raise(Error, "Defining a dataset method using a block requires only one argument") if args.length > 1
+            dataset_module{define_method(args.first, &block)}
+          else
+            args.each{|arg| def_model_dataset_method(arg)}
+          end
+        end
+
+        # Sets up a dataset method that returns a filtered dataset.
+        # Sometimes thought of as a scope, and like most dataset methods,
+        # they can be chained.
+        # For example:
+        #
+        #   Topic.subset(:joes, Sequel[:username].like('%joe%'))
+        #   Topic.subset(:popular){num_posts > 100}
+        #   Topic.subset(:recent){created_on > Date.today - 7}
+        #
+        # Allows you to do:
+        #
+        #   Topic.joes.recent.popular
+        #
+        # to get topics with a username that includes joe that
+        # have more than 100 posts and were created less than
+        # 7 days ago.
+        #
+        # Both the args given and the block are passed to <tt>Dataset#where</tt>.
+        #
+        # This method creates dataset methods that do not accept arguments.  To create
+        # dataset methods that accept arguments, you should use define a
+        # method directly inside a #dataset_module block.
+        def subset(*args, &block)
+          dataset_module{subset(*args, &block)}
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/defaults_setter.rb

@@ -1,12 +1,46 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
-    # DefaultsSetter is a simple plugin that sets non-nil/NULL default values upon
-    # initialize:
+    # The defaults_setter plugin makes the column getter methods return the default
+    # values for new objects, if the values have not already been set.  Example:
     #
     #   # column a default NULL
     #   # column b default 2
-    #   album = Album.new.values # {:b => 2}
-    #   album = Album.new(:a=>1, :b=>3).values # {:a => 1, :b => 3}
+    #   album = Album.new
+    #   album.a # => nil
+    #   album.b # => 2
+    #   album = Album.new(a: 1, b: 3)
+    #   album.a # => 1
+    #   album.b # => 3
+    #
+    # You can manually set default values as well:
+    #
+    #   Album.default_values[:a] = 4
+    #   Album.new.a # => 4
+    #
+    # You can also provide procs to set default values:
+    #
+    #   Album.default_values[:a] = lambda{Date.today}
+    #   Album.new.a # => Date.today
+    #
+    # By default, default values returned are not cached:
+    #
+    #   Album.new.a.equal?(Album.new.a) # => false
+    #
+    # However, you can turn on caching of default values:
+    #
+    #   Album.plugin :defaults_setter, cache: true
+    #   Album.new.a.equal?(Album.new.a) # => false
+    #
+    # Note that if the cache is turned on, the cached values are stored in
+    # the values hash:
+    #
+    #   Album.plugin :defaults_setter, cache: true
+    #   album = Album.new
+    #   album.values # => {}
+    #   album.a
+    #   album.values # => {:a => Date.today}
     # 
     # Usage:
     #
@@ -16,27 +50,52 @@ module Sequel
     #   # Make the Album class set defaults 
     #   Album.plugin :defaults_setter
     module DefaultsSetter
-      # Set the default values based on the model schema
-      def self.configure(model)
-        model.send(:set_default_values)
+      # Set the default values based on the model schema. Options:
+      # :cache :: Cache default values returned in the model's values hash.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          set_default_values
+          @cache_default_values = opts[:cache] if opts.has_key?(:cache)
+        end
       end
 
       module ClassMethods
-        # The default values to set in initialize for this model.  A hash with column symbol
+        # The default values to use for this model.  A hash with column symbol
         # keys and default values.  If the default values respond to +call+, it will be called
         # to get the value, otherwise the value will be used directly.  You can manually modify
         # this hash to set specific default values, by default the ones will be parsed from the database.
         attr_reader :default_values
-        
+
         Plugins.after_set_dataset(self, :set_default_values)
 
+        Plugins.inherited_instance_variables(self, :@default_values=>:dup, :@cache_default_values=>nil)
+
+        # Whether default values should be cached in the values hash after being retrieved.
+        def cache_default_values?
+          @cache_default_values
+        end
+        
+        # Freeze default values when freezing model class
+        def freeze
+          @default_values.freeze
+          super
+        end
+
         private
 
         # Parse the cached database schema for this model and set the default values appropriately.
         def set_default_values
           h = {}
-          @db_schema.each{|k, v| h[k] = convert_default_value(v[:ruby_default]) unless v[:ruby_default].nil?} if @db_schema
-          @default_values = h
+          if @db_schema
+            @db_schema.each do |k, v|
+              if v[:callable_default]
+                h[k] = v[:callable_default]
+              elsif !v[:ruby_default].nil?
+                h[k] = convert_default_value(v[:ruby_default])
+              end
+            end
+          end
+          @default_values = h.merge!(@default_values || OPTS)
         end
 
         # Handle the CURRENT_DATE and CURRENT_TIMESTAMP values specially by returning an appropriate Date or
@@ -57,8 +116,10 @@ module Sequel
         # Use default value for a new record if values doesn't already contain an entry for it.
         def [](k)
           if new? && !values.has_key?(k)
-            v = model.default_values[k]
-            v.respond_to?(:call) ? v.call : v
+            v = model.default_values.fetch(k){return}
+            v = v.call if v.respond_to?(:call)
+            values[k] = v if model.cache_default_values?
+            v
           else
             super
           end

data/lib/sequel/plugins/delay_add_association.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The delay_add_association plugin delays the adding of
@@ -36,8 +38,9 @@ module Sequel
         # current object.
         def add_associated_object(opts, o, *args)
           if opts.dataset_need_primary_key? && new?
+            o = make_add_associated_object(opts, o)
             delay_validate_associated_object(opts, o)
-            send(opts[:name]) << o
+            public_send(opts[:name]) << o
             after_create_hook{super(opts, o, *args)}
             o
           else

data/lib/sequel/plugins/dirty.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The dirty plugin makes Sequel save the initial value of
@@ -39,6 +41,15 @@ module Sequel
     #   artist.column_changes        # => {}
     #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
     #
+    #   artist.column_previously_was(:name)
+    #   # => 'Foo'
+    #   artist.column_previously_changed?(:name)
+    #   # => true
+    #   artist.column_previously_changed?(:name, from: 'Foo', to: 'Bar')
+    #   # => true
+    #   artist.column_previously_changed?(:name, from: 'Foo', to: 'Baz')
+    #   # => false
+    #
     # There is one caveat; when used with a column that also uses the
     # serialization plugin, setting the column back to its original value
     # after changing it is not correctly detected and will leave an entry
@@ -59,6 +70,19 @@ module Sequel
         # that were used in the update statement.
         attr_reader :previous_changes
 
+        # Reset the initial values after saving.
+        def after_save
+          super
+          reset_initial_values
+        end
+
+        # Save the current changes so they are available after updating.  This happens
+        # before after_save resets them.
+        def after_update
+          super
+          @previous_changes = column_changes
+        end
+
         # An array with the initial value and the current value
         # of the column, if the column has been changed.  If the
         # column has not been changed, returns nil.
@@ -90,6 +114,41 @@ module Sequel
           initial_values.has_key?(column)
         end
 
+        # Whether the column was previously changed.
+        # Options:
+        # :from :: If given, the previous initial value of the column must match this
+        # :to :: If given, the previous changed value of the column must match this
+        #
+        #   update(name: 'Current')
+        #   previous_changes                  # => {:name=>['Initial', 'Current']}
+        #   column_previously_changed?(:name) # => true
+        #   column_previously_changed?(:id)   # => false
+        #   column_previously_changed?(:name, from: 'Initial', to: 'Current') # => true
+        #   column_previously_changed?(:name, from: 'Foo', to: 'Current')     # => false
+        def column_previously_changed?(column, opts=OPTS)
+          return false unless (pc = @previous_changes) && (val = pc[column])
+
+          if opts.has_key?(:from)
+            return false unless val[0] == opts[:from]
+          end
+
+          if opts.has_key?(:to)
+            return false unless val[1] == opts[:to]
+          end
+
+          true
+        end
+
+        # The previous value of the column, which is the initial value of
+        # the column before the object was previously saved.
+        #
+        #   initial_value(:name) # => 'Initial'
+        #   update(name: 'Current')
+        #   column_previously_was(:name) # => 'Initial'
+        def column_previously_was(column)
+          (pc = @previous_changes) && (val = pc[column]) && val[0]
+        end
+
         # Freeze internal data structures
         def freeze
           initial_values.freeze
@@ -128,6 +187,7 @@ module Sequel
           end
         end
 
+        # Manually specify that a column will change.  This should only be used
         # Manually specify that a column will change.  This should only be used
         # if you plan to modify a column value in place, which is not recommended.
         #
@@ -135,7 +195,7 @@ module Sequel
         #   name.gsub(/i/i, 'o')
         #   column_change(:name) # => ['Initial', 'onotoal']
         def will_change_column(column)
-          changed_columns << column unless changed_columns.include?(column)
+          _add_changed_column(column)
           check_missing_initial_value(column)
 
           value = if initial_values.has_key?(column)
@@ -157,23 +217,10 @@ module Sequel
 
         private
 
-        # Reset the initial values when setting values.
-        def _refresh_set_values(hash)
-          reset_initial_values
-          super
-        end
-
-        # Reset the initial values after saving.
-        def after_save
+        # Reset initial values when clearing changed columns
+        def _clear_changed_columns(reason)
+          reset_initial_values if reason == :initialize || reason == :refresh
           super
-          reset_initial_values
-        end
-
-        # Save the current changes so they are available after updating.  This happens
-        # before after_save resets them.
-        def after_update
-          super
-          @previous_changes = column_changes
         end
 
         # When changing the column value, save the initial column value.  If the column
@@ -184,7 +231,7 @@ module Sequel
             initial = iv[column]
             super
             if value == initial
-              changed_columns.delete(column) unless missing_initial_values.include?(column)
+              _changed_columns.delete(column) unless missing_initial_values.include?(column)
               iv.delete(column)
             end
           else
@@ -212,12 +259,6 @@ module Sequel
           self
         end
 
-        # Reset the initial values when initializing.
-        def initialize_set(h)
-          super
-          reset_initial_values
-        end
-
         # Array holding column symbols that were not present initially.  This is necessary
         # to differentiate between values that were not present and values that were
         # present but equal to nil.