sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/lazy_attributes.rb

@@ -13,7 +13,7 @@ module Sequel
     # get the reviews for all of those albums:
     #
     #   Album.plugin :lazy_attributes, :review
-    #   Album.filter{id<100}.all do |a|
+    #   Album.where{id < 100}.all do |a|
     #     a.review
     #   end
     #
@@ -38,9 +38,12 @@ module Sequel
       end
       
       module ClassMethods
-        # Module to store the lazy attribute getter methods, so they can
-        # be overridden and call super to get the lazy attribute behavior
-        attr_accessor :lazy_attributes_module
+        # Freeze lazy attributes module when freezing model class.
+        def freeze
+          @lazy_attributes_module.freeze if @lazy_attributes_module
+
+          super
+        end
 
         # Remove the given attributes from the list of columns selected by default.
         # For each attribute given, create an accessor method that allows a lazy
@@ -49,7 +52,9 @@ module Sequel
           unless select = dataset.opts[:select]
             select = dataset.columns.map{|c| Sequel.qualify(dataset.first_source, c)}
           end
+          db_schema = @db_schema
           set_dataset(dataset.select(*select.reject{|c| attrs.include?(dataset.send(:_hash_key_symbol, c))}))
+          @db_schema = db_schema
           attrs.each{|a| define_lazy_attribute_getter(a)}
         end
         
@@ -59,8 +64,8 @@ module Sequel
         # :dataset :: The base dataset to use for the lazy attribute lookup
         # :table :: The table name to use to qualify the attribute and primary key columns.
         def define_lazy_attribute_getter(a, opts=OPTS)
-          include(self.lazy_attributes_module ||= Module.new) unless lazy_attributes_module
-          lazy_attributes_module.class_eval do
+          include(@lazy_attributes_module ||= Module.new) unless @lazy_attributes_module
+          @lazy_attributes_module.class_eval do
             define_method(a) do
               if !values.has_key?(a) && !new?
                 lazy_attribute_lookup(a, opts)
@@ -68,6 +73,7 @@ module Sequel
                 super()
               end
             end
+            alias_method(a, a)
           end
         end
       end
@@ -80,9 +86,8 @@ module Sequel
         # the attribute for just the current object.  Return the value of
         # the attribute for the current object.
         def lazy_attribute_lookup(a, opts=OPTS)
-          unless table = opts[:table]
-            table = model.table_name
-          end
+          table = opts[:table] || model.table_name
+          selection = Sequel.qualify(table, a)
 
           if base_ds = opts[:dataset]
             ds = base_ds.where(qualified_pk_hash(table))
@@ -91,19 +96,21 @@ module Sequel
             ds = this
           end
 
-          selection = Sequel.qualify(table, a)
-
           if frozen?
-            return ds.dup.get(selection)
+            return ds.get(selection)
           end
 
           if retrieved_with
-            raise(Error, "Invalid primary key column for #{model}: #{pkc.inspect}") unless primary_key = model.primary_key
+            primary_key = model.primary_key
             composite_pk = true if primary_key.is_a?(Array)
             id_map = {}
             retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}
             predicate_key = composite_pk ? primary_key.map{|k| Sequel.qualify(table, k)} : Sequel.qualify(table, primary_key)
-            base_ds.select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).where(predicate_key=>id_map.keys).naked.each do |row|
+            base_ds.
+             select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).
+             where(predicate_key=>id_map.keys).
+             naked.
+             each do |row|
               obj = id_map[composite_pk ? row.values_at(*primary_key) : row[primary_key]]
               if obj && !obj.values.has_key?(a)
                 obj.values[a] = row[a]

data/lib/sequel/plugins/list.rb

@@ -11,7 +11,7 @@ module Sequel
     #
     #   class Item < Sequel::Model(:items)
     #     plugin :list # will use :position field for position
-    #     plugin :list, :field=>:pos # will use :pos field for position
+    #     plugin :list, field: :pos # will use :pos field for position
     #   end
     #   
     #   item = Item[1]
@@ -33,39 +33,48 @@ module Sequel
     # You can provide a <tt>:scope</tt> option to scope the list.  This option
     # can be a symbol or array of symbols specifying column name(s), or a proc
     # that accepts a model instance and returns a dataset representing the list
-    # the object is in.
+    # the object is in.  You will need to provide a <tt>:scope</tt> option if
+    # the model's dataset uses a subquery (such as when using the class_table_inheritance
+    # plugin).
     # 
     # For example, if each item has a +user_id+ field, and you want every user
     # to have their own list:
     #
-    #   Item.plugin :list, :scope=>:user_id
+    #   Item.plugin :list, scope: :user_id
     # 
     # Note that using this plugin modifies the order of the model's dataset to
     # sort by the position and scope fields.  Also note that this plugin is subject to
     # race conditions, and is not safe when concurrent modifications are made
     # to the same list.
     #
-    # Additionally, note that unlike ruby arrays, the list plugin assumes that the
-    # first entry in the list has position 1, not position 0.
+    # Note that by default, unlike ruby arrays, the list plugin assumes the first
+    # entry in the list has position 1, not position 0.
+    #
+    # You can change this by providing an integer <tt>:top</tt> option:
+    #
+    #   Item.plugin :list, top: 0
     #
     # Copyright (c) 2007-2010 Sharon Rosner, Wayne E. Seguin, Aman Gupta, Adrian Madrid, Jeremy Evans
     module List
-      # Set the +position_field+ and +scope_proc+ attributes for the model,
-      # using the <tt>:field</tt> and <tt>:scope</tt> options, respectively.
+      # Set the +position_field+, +scope_proc+ and +top_of_list+ attributes for the model,
+      # using the <tt>:field</tt>, <tt>:scope</tt>, and <tt>:top</tt> options, respectively.
       # The <tt>:scope</tt> option can be a symbol, array of symbols, or a proc that
       # accepts a model instance and returns a dataset representing the list.
       # Also, modify the model dataset's order to order by the position and scope fields.
       def self.configure(model, opts = OPTS)
         model.position_field = opts[:field] || :position
         model.dataset = model.dataset.order_prepend(model.position_field)
+        model.instance_exec do
+          @top_of_list = opts[:top] || 1
+        end
         
         model.scope_proc = case scope = opts[:scope]
         when Symbol
           model.dataset = model.dataset.order_prepend(scope)
-          proc{|obj| obj.model.filter(scope=>obj.send(scope))}
+          proc{|obj| obj.model.where(scope=>obj.public_send(scope))}
         when Array
           model.dataset = model.dataset.order_prepend(*scope)
-          proc{|obj| obj.model.filter(scope.map{|s| [s, obj.get_column_value(s)]})}
+          proc{|obj| obj.model.where(scope.map{|s| [s, obj.get_column_value(s)]})}
         else
           scope
         end
@@ -80,7 +89,10 @@ module Sequel
         # proc should accept an instance and return a dataset representing the list.
         attr_accessor :scope_proc
 
-        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil)
+        # An Integer to use as the position of the top of the list. Defaults to 1.
+        attr_reader :top_of_list
+
+        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil, :@top_of_list=>nil)
       end
 
       module InstanceMethods
@@ -94,7 +106,7 @@ module Sequel
         def after_destroy
           super
 
-          f = Sequel.expr(position_field)
+          f = Sequel[position_field]
           list_dataset.where(f > position_value).update(f => f - 1)
         end
 
@@ -114,20 +126,22 @@ module Sequel
           move_to(position_value + n)
         end
 
-        # Move this instance to the given place in the list.  Raises an
-        # exception if target is less than 1 or greater than the last position in the list.
+        # Move this instance to the given place in the list.  If lp is not
+        # given or greater than the last list position, uses the last list
+        # position.  If lp is less than the top list position, uses the
+        # top list position.
         def move_to(target, lp = nil)
           current = position_value
           if target != current
             checked_transaction do
               ds = list_dataset
               op, ds = if target < current
-                target = 1 if target < 1
-                [:+, ds.filter(position_field=>target...current)]
+                target = model.top_of_list if target < model.top_of_list
+                [:+, ds.where(position_field=>target...current)]
               else
                 lp ||= last_position
                 target = lp if target > lp
-                [:-, ds.filter(position_field=>(current + 1)..target)]
+                [:-, ds.where(position_field=>(current + 1)..target)]
               end
               ds.update(position_field => Sequel::SQL::NumericExpression.new(op, position_field, 1))
               update(position_field => target)
@@ -142,9 +156,9 @@ module Sequel
           move_to(lp, lp)
         end
 
-        # Move this instance to the top (first position, position 1) of the list.
+        # Move this instance to the top (first position, usually position 1) of the list.
         def move_to_top
-          move_to(1)
+          move_to(model.top_of_list)
         end
 
         # Move this instance the given number of places up in the list, or 1 place
@@ -170,17 +184,17 @@ module Sequel
           self.next(n * -1)
         end
 
-        private
-
         # Set the value of the position_field to the maximum value plus 1 unless the
         # position field already has a value.
-        def _before_validation
+        def before_validation
           unless get_column_value(position_field)
             set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
           end
           super
         end
 
+        private
+
         # The model's position field, an instance method for ease of use.
         def position_field
           model.position_field

data/lib/sequel/plugins/many_through_many.rb

@@ -46,18 +46,18 @@ module Sequel
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]]
     #
     #   # All albums by artists that are associated to any album that this artist is associated to
-    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id], \
-    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]], \
-    #    :class=>:Album
+    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id],
+    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]],
+    #    class: :Album
     #
     #   # All tracks on albums by this artist (also could be a many_to_many)
-    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]], \
-    #    :right_primary_key=>:album_id
+    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]],
+    #    right_primary_key: :album_id
     #
     # Often you don't want the current object to appear in the array of associated objects.  This is easiest to handle via an :after_load hook:
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]],
-    #     :after_load=>proc{|artist, associated_artists| associated_artists.delete(artist)}
+    #     after_load: lambda{|artist, associated_artists| associated_artists.delete(artist)}
     #
     # You can also handle it by adding a dataset block that excludes the current record (so it won't be retrieved at all), but
     # that won't work when eagerly loading, which is why the :after_load proc is recommended instead.
@@ -65,7 +65,7 @@ module Sequel
     # It's also common to not want duplicate records, in which case the :distinct option can be used:
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]],
-    #    :distinct=>true
+    #    distinct: true
     # 
     # In addition to many_through_many, this plugin also adds one_through_many, for an association to a single object through multiple join tables.
     # This is useful if there are unique constraints on the foreign keys in the join tables that reference back to the current table, or if you want
@@ -81,7 +81,7 @@ module Sequel
     module ManyThroughMany
       # The AssociationReflection subclass for many_through_many associations.
       class ManyThroughManyAssociationReflection < Sequel::Model::Associations::ManyToManyAssociationReflection
-        Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self
+        Sequel.synchronize{Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self}
 
         # many_through_many and one_through_many associations can be clones
         def cloneable?(ref)
@@ -102,6 +102,17 @@ module Sequel
           END
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :associated_key_table=>:associated_key_table,
+          :edges=>:edges,
+          :final_edge=>:final_edge,
+          :final_reverse_edge=>:final_reverse_edge,
+          :reverse_edges=>:reverse_edges
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # The alias for the first join table.
         def join_table_alias
           final_reverse_edge[:alias]
@@ -112,16 +123,25 @@ module Sequel
           nil
         end
 
+        # Whether a separate query should be used for each join table.
+        def separate_query_per_table?
+          self[:separate_query_per_table]
+        end
+
         private
 
         def _associated_dataset
           ds = associated_class
-          (reverse_edges + [final_reverse_edge]).each do |t|
-            h = {:qualify=>:deep}
-            if t[:alias] != t[:table]
-              h[:table_alias] = t[:alias]
+          if separate_query_per_table?
+            ds = ds.dataset
+          else
+            (reverse_edges + [final_reverse_edge]).each do |t|
+              h = {:qualify=>:deep}
+              if t[:alias] != t[:table]
+                h[:table_alias] = t[:alias]
+              end
+              ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), h)
             end
-            ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), h)
           end
           ds
         end
@@ -133,7 +153,7 @@ module Sequel
             table_alias = e[:table]
             if aliases.include?(table_alias)
               i = 0
-              table_alias = loop do
+              table_alias = while true
                 ta = :"#{table_alias}_#{i}"
                 break ta unless aliases.include?(ta)
                 i += 1
@@ -181,7 +201,7 @@ module Sequel
       end
 
       class OneThroughManyAssociationReflection < ManyThroughManyAssociationReflection
-        Sequel::Model::Associations::ASSOCIATION_TYPES[:one_through_many] = self
+        Sequel.synchronize{Sequel::Model::Associations::ASSOCIATION_TYPES[:one_through_many] = self}
         include Sequel::Model::Associations::SingularAssociationReflection
       end
 
@@ -197,6 +217,7 @@ module Sequel
         #            :right (last array element) :: The key joining the table to the next table. Can use an
         #                                           array of symbols for a composite key association.
         #            If a hash is provided, the following keys are respected when using eager_graph:
+        #            :db :: The Database containing the table.  This changes lookup to use a separate query for each join table.
         #            :block :: A proc to use as the block argument to join.
         #            :conditions :: Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
         #            :join_type :: The join type to use for the join, defaults to :left_outer.
@@ -217,34 +238,126 @@ module Sequel
         def def_many_through_many(opts)
           one_through_many = opts[:type] == :one_through_many
           opts[:read_only] = true
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:cartesian_product_number] ||= one_through_many ? 0 : 2
-          opts[:through] = opts[:through].map do |e|
+          separate_query_per_table = false
+          through = opts[:through] = opts[:through].map do |e|
             case e
             when Array
               raise(Error, "array elements of the through option/argument for many_through_many associations must have at least three elements") unless e.length == 3
               {:table=>e[0], :left=>e[1], :right=>e[2]}
             when Hash
               raise(Error, "hash elements of the through option/argument for many_through_many associations must contain :table, :left, and :right keys") unless e[:table] && e[:left] && e[:right]
+              separate_query_per_table = true if e[:db]
               e
             else
               raise(Error, "the through option/argument for many_through_many associations must be an enumerable of arrays or hashes")
             end
           end
+          opts[:separate_query_per_table] = separate_query_per_table
 
           left_key = opts[:left_key] = opts[:through].first[:left]
           opts[:left_keys] = Array(left_key)
-          opts[:uses_left_composite_keys] = left_key.is_a?(Array)
+          uses_lcks = opts[:uses_left_composite_keys] = left_key.is_a?(Array)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
           raise(Error, "no primary key specified for #{inspect}") unless left_pk
           opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk
           lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
-          opts[:dataset] ||= opts.association_dataset_proc
 
           opts[:left_key_alias] ||= opts.default_associated_key_alias
-          opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          if separate_query_per_table
+            opts[:use_placeholder_loader] = false
+            opts[:allow_eager_graph] = false
+            opts[:allow_filtering_by] = false
+            opts[:eager_limit_strategy] = nil
+
+            opts[:dataset] ||= proc do |r|
+              def_db = r.associated_class.db
+              vals = uses_lcks ? [lpkcs.map{|k| get_column_value(k)}] : get_column_value(left_pk)
+
+              has_results = through.each do |edge|
+                ds = (edge[:db] || def_db).from(edge[:table]).where(edge[:left]=>vals)
+                ds = ds.where(edge[:conditions]) if edge[:conditions]
+                right = edge[:right]
+                vals = ds.select_map(right)
+                if right.is_a?(Array)
+                  vals.delete_if{|v| v.any?(&:nil?)}
+                else
+                  vals.delete(nil)
+                end
+                break if vals.empty?
+              end
+
+              ds = r.associated_dataset.where(opts.right_primary_key=>vals)
+              ds = ds.clone(:no_results=>true) unless has_results
+              ds
+            end
+            opts[:eager_loader] ||= proc do |eo|
+              h = eo[:id_map]
+              assign_singular = opts.assign_singular?
+              uses_rcks = opts.right_primary_key.is_a?(Array)
+              rpk = uses_rcks ? opts.right_primary_keys : opts.right_primary_key
+              name = opts[:name]
+              def_db = opts.associated_class.db
+              join_map = h
+
+              run_query = through.each do |edge|
+                ds = (edge[:db] || def_db).from(edge[:table])
+                ds = ds.where(edge[:conditions]) if edge[:conditions]
+                left = edge[:left]
+                right = edge[:right]
+                prev_map = join_map
+                join_map = ds.where(left=>join_map.keys).select_hash_groups(right, left)
+                if right.is_a?(Array)
+                  join_map.delete_if{|v,| v.any?(&:nil?)}
+                else
+                  join_map.delete(nil)
+                end
+                break if join_map.empty?
+                join_map.each_value do |vs|
+                  vs.replace(vs.flat_map{|v| prev_map[v]})
+                  vs.uniq!
+                end
+              end
+
+              eo = Hash[eo]
+
+              if run_query
+                eo[:loader] = false
+                eo[:right_keys] = join_map.keys
+              else
+                eo[:no_results] = true
+              end
+
+              opts[:model].eager_load_results(opts, eo) do |assoc_record|
+                rpkv = if uses_rcks
+                  assoc_record.values.values_at(*rpk)
+                else
+                  assoc_record.values[rpk]
+                end
+
+                objects = join_map[rpkv]
+
+                if assign_singular
+                  objects.each do |object|
+                    object.associations[name] ||= assoc_record
+                  end
+                else
+                  objects.each do |object|
+                    object.associations[name].push(assoc_record)
+                  end
+                end
+              end
+            end
+          else
+            opts[:dataset] ||= opts.association_dataset_proc
+            opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          end
 
           join_type = opts[:graph_join_type]
           select = opts[:graph_select]
@@ -272,7 +385,7 @@ module Sequel
                 iq = nil
               end
               fe = opts.final_edge
-              ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
+              ds.graph(opts.associated_class.dataset, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
             end
           end
         end

data/lib/sequel/plugins/modification_detection.rb

@@ -17,6 +17,9 @@ module Sequel
     # Note that for this plugin to work correctly, the column values must
     # correctly implement the #hash method, returning the same value if
     # the object is equal, and a different value if the object is not equal.
+    # As this solely uses hash values to check for modification, there may
+    # be cases where a modification is made and the hash value is the same,
+    # resulting in a false negative.
     #
     # Note that this plugin causes a performance hit for all retrieved
     # objects, so it shouldn't be used in cases where performance is a
@@ -55,13 +58,20 @@ module Sequel
         # Detect which columns have been modified by comparing the cached hash
         # value to the hash of the current value.
         def changed_columns
-          cc = super
-          changed = []
-          v = @values
+          changed = super
           if vh = @values_hashes
-            (vh.keys - cc).each{|c| changed << c unless v.has_key?(c) && vh[c] == v[c].hash}
+            values = @values
+            changed = changed.dup if frozen?
+            vh.each do |c, v|
+              match = values.has_key?(c) && v == values[c].hash
+              if changed.include?(c)
+                changed.delete(c) if match
+              else
+                changed << c unless match
+              end
+            end
           end
-          cc + changed
+          changed
         end
 
         private

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -12,15 +12,15 @@ module Sequel
     #   end
     #   p1 = Person[1]
     #   p2 = Person[1]
-    #   p1.update(:name=>'Jim') # works
-    #   p2.update(:name=>'Bob') # raises Sequel::NoExistingObject
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
     #
     # In order for this plugin to work, you need to make sure that the database
     # table has a column of timestamp or rowversion.  The plugin uses a default
     # name of timestamp for this columns, but you can override that using the
     # :lock_column option:
     #
-    #     plugin :mssql_optimistic_locking, :lock_column=>:column_name
+    #     plugin :mssql_optimistic_locking, lock_column: :column_name
     #
     # This plugin relies on the instance_filters plugin.
     module MssqlOptimisticLocking
@@ -75,7 +75,8 @@ module Sequel
         # it to be assigned.
         def _save_update_all_columns_hash
           v = @values.dup
-          Array(primary_key).each{|x| v.delete(x) unless changed_columns.include?(x)}
+          cc = changed_columns
+          Array(primary_key).each{|x| v.delete(x) unless cc.include?(x)}
           v.delete(model.lock_column)
           v
         end
@@ -84,7 +85,7 @@ module Sequel
         def _update_without_checking(columns)
           ds = _update_dataset
           lc = model.lock_column
-          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.output(nil, [Sequel.qualify(:inserted, lc)]).update_sql(columns))).all
+          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.output(nil, [Sequel[:inserted][lc]]).update_sql(columns))).all
           values[lc] = rows.first[lc] unless rows.empty?
           rows.length
         end