sequel 5.58.0 → 5.78.0

data/lib/sequel/model/base.rb

@@ -606,6 +606,7 @@ module Sequel
           @db_schema = get_db_schema
         end
 
+        @fast_pk_lookup_sql = @fast_instance_delete_sql = nil unless @dataset.supports_placeholder_literalizer?
         reset_instance_dataset
         self
       end
@@ -680,10 +681,11 @@ module Sequel
   
       private
       
-      # Yield to the passed block and if do_raise is false, swallow all errors other than DatabaseConnectionErrors.
+      # Yield to the passed block and if do_raise is false, swallow Sequel::Errors other than DatabaseConnectionError
+      # and DatabaseDisconnectError.
       def check_non_connection_error(do_raise=require_valid_table)
         db.transaction(:savepoint=>:only){yield}
-      rescue Sequel::DatabaseConnectionError
+      rescue Sequel::DatabaseConnectionError, Sequel::DatabaseDisconnectError
         raise
       rescue Sequel::Error
         raise if do_raise
@@ -693,9 +695,12 @@ module Sequel
       # this model's dataset.
       def convert_input_dataset(ds)
         case ds
-        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, LiteralString
+        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
           self.simple_table = db.literal(ds).freeze
           ds = db.from(ds)
+        when SQL::AliasedExpression, LiteralString
+          self.simple_table = nil
+          ds = db.from(ds)
         when Dataset
           ds = ds.from_self(:alias=>ds.first_source) if ds.joined_dataset?
 
@@ -784,7 +789,7 @@ module Sequel
         schema_hash = {}
         ds_opts = dataset.opts
         get_columns = proc{check_non_connection_error{columns} || []}
-        schema_array = check_non_connection_error(false){db.schema(dataset, :reload=>reload)} if db.supports_schema_parsing?
+        schema_array = get_db_schema_array(reload) if db.supports_schema_parsing?
         if schema_array
           schema_array.each{|k,v| schema_hash[k] = v}
 
@@ -821,6 +826,12 @@ module Sequel
         schema_hash
       end
 
+      # Get the array of schema information for the dataset.  Returns nil if
+      # the schema information cannot be determined.
+      def get_db_schema_array(reload)
+        check_non_connection_error(false){db.schema(dataset, :reload=>reload)}
+      end
+
       # Uncached version of setter_methods, to be overridden by plugins
       # that want to modify the methods used.
       def get_setter_methods
@@ -1131,7 +1142,7 @@ module Sequel
       #
       #   Artist[1] === Artist[1] # => true
       #   Artist.new === Artist.new # => false
-      #   Artist[1].set(:name=>'Bob') === Artist[1] # => true
+      #   Artist[1].set(name: 'Bob') === Artist[1] # => true
       def ===(obj)
         case pkv = pk
         when nil
@@ -1150,7 +1161,7 @@ module Sequel
       #
       #   Artist[1].pk_equal?(Artist[1]) # => true
       #   Artist.new.pk_equal?(Artist.new) # => false
-      #   Artist[1].set(:name=>'Bob').pk_equal?(Artist[1]) # => true
+      #   Artist[1].set(name: 'Bob').pk_equal?(Artist[1]) # => true
       alias pk_equal? ===
 
       # class is defined in Object, but it is also a keyword,
@@ -1222,7 +1233,7 @@ module Sequel
       #
       #   Artist[1] == Artist[1] # => true
       #   Artist.new == Artist.new # => true
-      #   Artist[1].set(:name=>'Bob') == Artist[1] # => false
+      #   Artist[1].set(name: 'Bob') == Artist[1] # => false
       def eql?(obj)
         (obj.class == model) && (obj.values == @values)
       end
@@ -1233,18 +1244,21 @@ module Sequel
         @errors ||= errors_class.new
       end 
 
+      EXISTS_SELECT_ = SQL::AliasedExpression.new(1, :one)
+      private_constant :EXISTS_SELECT_
+
       # Returns true when current instance exists, false otherwise.
       # Generally an object that isn't new will exist unless it has
       # been deleted.  Uses a database query to check for existence,
       # unless the model object is new, in which case this is always
       # false.
       #
-      #   Artist[1].exists? # SELECT 1 FROM artists WHERE (id = 1)
+      #   Artist[1].exists? # SELECT 1 AS one FROM artists WHERE (id = 1)
       #   # => true
       #   Artist.new.exists?
       #   # => false
       def exists?
-        new? ? false : !this.get(SQL::AliasedExpression.new(1, :one)).nil?
+        new? ? false : !this.get(EXISTS_SELECT_).nil?
       end
       
       # Ignore the model's setter method cache when this instances extends a module, as the
@@ -1324,13 +1338,13 @@ module Sequel
       #   a = Artist[1]
       #   Artist.db.transaction do
       #     a.lock!
-      #     a.update(:name=>'A')
+      #     a.update(name: 'A')
       #   end
       #
       #   a = Artist[2]
       #   Artist.db.transaction do
       #     a.lock!('FOR NO KEY UPDATE')
-      #     a.update(:name=>'B')
+      #     a.update(name: 'B')
       #   end
       def lock!(style=:update)
         _refresh(this.lock_style(style)) unless new?
@@ -1934,8 +1948,10 @@ module Sequel
       end
       
       # If transactions should be used, wrap the yield in a transaction block.
-      def checked_transaction(opts=OPTS)
-        use_transaction?(opts) ? db.transaction({:server=>this_server}.merge!(opts)){yield} : yield
+      def checked_transaction(opts=OPTS, &block)
+        h = {:server=>this_server}.merge!(opts)
+        h[:skip_transaction] = true unless use_transaction?(opts)
+        db.transaction(h, &block)
       end
 
       # Change the value of the column to given value, recording the change.
@@ -2020,19 +2036,20 @@ module Sequel
         meths = setter_methods(type)
         strict = strict_param_setting
         hash.each do |k,v|
+          k = k.to_s
           m = "#{k}="
           if meths.include?(m)
             set_column_value(m, v)
           elsif strict
             # Avoid using respond_to? or creating symbols from user input
             if public_methods.map(&:to_s).include?(m)
-              if Array(model.primary_key).map(&:to_s).member?(k.to_s) && model.restrict_primary_key?
-                raise MassAssignmentRestriction, "#{k} is a restricted primary key"
+              if Array(model.primary_key).map(&:to_s).member?(k) && model.restrict_primary_key?
+                raise MassAssignmentRestriction.create("#{k} is a restricted primary key", self, k)
               else
-                raise MassAssignmentRestriction, "#{k} is a restricted column"
+                raise MassAssignmentRestriction.create("#{k} is a restricted column", self, k)
               end
             else
-              raise MassAssignmentRestriction, "method #{m} doesn't exist"
+              raise MassAssignmentRestriction.create("method #{m} doesn't exist", self, k)
             end
           end
         end
@@ -2136,8 +2153,9 @@ module Sequel
       #   # DELETE FROM artists WHERE (id = 2)
       #   # ...
       def destroy
-        pr = proc{all(&:destroy).length}
-        model.use_transactions ? @db.transaction(:server=>opts[:server], &pr) : pr.call
+        @db.transaction(:server=>opts[:server], :skip_transaction=>model.use_transactions == false) do
+          all(&:destroy).length
+        end
       end
 
       # If there is no order already defined on this dataset, order it by
@@ -2217,11 +2235,17 @@ module Sequel
 
       private
 
+      # Return the dataset ordered by the model's primary key.  This should not
+      # be used if the model does not have a primary key.
+      def _force_primary_key_order
+        cached_dataset(:_pk_order_ds){order(*model.primary_key)}
+      end
+
       # If the dataset is not already ordered, and the model has a primary key,
       # return a clone ordered by the primary key.
       def _primary_key_order
-        if @opts[:order].nil? && model && (pk = model.primary_key)
-          cached_dataset(:_pk_order_ds){order(*pk)}
+        if @opts[:order].nil? && model && model.primary_key
+          _force_primary_key_order
         end
       end
 

data/lib/sequel/model/dataset_module.rb

@@ -8,6 +8,9 @@ module Sequel
     # automatically creates class methods for public dataset
     # methods.
     class DatasetModule < Dataset::DatasetModule
+      # The model class related to this dataset module.
+      attr_reader :model
+
       # Store the model related to this dataset module.
       def initialize(model)
         @model = model

data/lib/sequel/model/exceptions.rb

@@ -24,11 +24,23 @@ module Sequel
   UndefinedAssociation = Class.new(Error)
   ).name
 
-  (
   # Raised when a mass assignment method is called in strict mode with either a restricted column
   # or a column without a setter method.
-  MassAssignmentRestriction = Class.new(Error)
-  ).name
+  class MassAssignmentRestriction < Error
+    # The Sequel::Model object related to this exception.
+    attr_reader :model
+
+    # The column related to this exception, as a string.
+    attr_reader :column
+
+    # Create an instance of this class with the model and column set.
+    def self.create(msg, model, column)
+      e = new("#{msg} for class #{model.class.inspect}")
+      e.instance_variable_set(:@model, model)
+      e.instance_variable_set(:@column, column)
+      e
+    end
+  end
   
   # Exception class raised when +raise_on_save_failure+ is set and validation fails
   class ValidationFailed < Error

data/lib/sequel/plugins/auto_validations.rb

@@ -9,14 +9,16 @@ module Sequel
     # 2. not_null validations on NOT NULL columns (optionally, presence validations)
     # 3. unique validations on columns or sets of columns with unique indexes
     # 4. max length validations on string columns
+    # 5. no null byte validations on string columns
+    # 6. minimum and maximum values on columns
     #
-    # To determine the columns to use for the type/not_null/max_length validations,
+    # To determine the columns to use for the type/not_null/max_length/no_null_byte/max_value/min_value validations,
     # the plugin looks at the database schema for the model's table.  To determine
     # the unique validations, Sequel looks at the indexes on the table.  In order
     # for this plugin to be fully functional, the underlying database adapter needs
     # to support both schema and index parsing.  Additionally, unique validations are
     # only added for models that select from a simple table, they are not added for models
-    # that select from a subquery or joined dataset.
+    # that select from a subquery.
     #
     # This plugin uses the validation_helpers plugin underneath to implement the
     # validations.  It does not allow for any per-column validation message
@@ -50,7 +52,7 @@ module Sequel
     #
     #   Model.plugin :auto_validations, unique_opts: {only_if_modified: true}
     #
-    # This works for unique_opts, max_length_opts, schema_types_opts,
+    # This works for unique_opts, max_length_opts, schema_types_opts, max_value_opts, min_value_opts, no_null_byte_opts,
     # explicit_not_null_opts, and not_null_opts.
     #
     # If you only want auto_validations to add validations to columns that do not already
@@ -72,6 +74,19 @@ module Sequel
       SCHEMA_TYPES_OPTIONS = NOT_NULL_OPTIONS
       UNIQUE_OPTIONS = NOT_NULL_OPTIONS
       NO_NULL_BYTE_OPTIONS = MAX_LENGTH_OPTIONS
+      MAX_VALUE_OPTIONS = {:from=>:values, :allow_nil=>true, :skip_invalid=>true}.freeze
+      MIN_VALUE_OPTIONS = MAX_VALUE_OPTIONS
+      AUTO_VALIDATE_OPTIONS = {
+        :no_null_byte=>NO_NULL_BYTE_OPTIONS,
+        :not_null=>NOT_NULL_OPTIONS,
+        :explicit_not_null=>EXPLICIT_NOT_NULL_OPTIONS,
+        :max_length=>MAX_LENGTH_OPTIONS,
+        :max_value=>MAX_VALUE_OPTIONS,
+        :min_value=>MIN_VALUE_OPTIONS,
+        :schema_types=>SCHEMA_TYPES_OPTIONS,
+        :unique=>UNIQUE_OPTIONS
+      }.freeze
+
       EMPTY_ARRAY = [].freeze
 
       def self.apply(model, opts=OPTS)
@@ -82,17 +97,11 @@ module Sequel
           @auto_validate_not_null_columns = []
           @auto_validate_explicit_not_null_columns = []
           @auto_validate_max_length_columns = []
+          @auto_validate_max_value_columns = []
+          @auto_validate_min_value_columns = []
           @auto_validate_unique_columns = []
           @auto_validate_types = true
-
-          @auto_validate_options = {
-              :no_null_byte=>NO_NULL_BYTE_OPTIONS,
-              :not_null=>NOT_NULL_OPTIONS,
-              :explicit_not_null=>EXPLICIT_NOT_NULL_OPTIONS,
-              :max_length=>MAX_LENGTH_OPTIONS,
-              :schema_types=>SCHEMA_TYPES_OPTIONS,
-              :unique=>UNIQUE_OPTIONS
-          }.freeze
+          @auto_validate_options = AUTO_VALIDATE_OPTIONS
         end
       end
 
@@ -105,7 +114,7 @@ module Sequel
           end
 
           h = @auto_validate_options.dup
-          [:not_null, :explicit_not_null, :max_length, :no_null_byte, :schema_types, :unique].each do |type|
+          [:not_null, :explicit_not_null, :max_length, :max_value, :min_value, :no_null_byte, :schema_types, :unique].each do |type|
             if type_opts = opts[:"#{type}_opts"]
               h[type] = h[type].merge(type_opts).freeze
             end
@@ -135,6 +144,14 @@ module Sequel
         # pairs, with the first entry being the column name and second entry being the maximum length.
         attr_reader :auto_validate_max_length_columns
 
+        # The columns with automatch max value validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the maximum value.
+        attr_reader :auto_validate_max_value_columns
+
+        # The columns with automatch min value validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the minimum value.
+        attr_reader :auto_validate_min_value_columns
+
         # The columns or sets of columns with automatic unique validations
         attr_reader :auto_validate_unique_columns
 
@@ -148,6 +165,8 @@ module Sequel
           :@auto_validate_not_null_columns=>:dup,
           :@auto_validate_explicit_not_null_columns=>:dup,
           :@auto_validate_max_length_columns=>:dup,
+          :@auto_validate_max_value_columns=>:dup,
+          :@auto_validate_min_value_columns=>:dup,
           :@auto_validate_unique_columns=>:dup,
           :@auto_validate_options => :dup)
         Plugins.after_set_dataset(self, :setup_auto_validations)
@@ -168,18 +187,23 @@ module Sequel
           @auto_validate_not_null_columns.freeze
           @auto_validate_explicit_not_null_columns.freeze
           @auto_validate_max_length_columns.freeze
+          @auto_validate_max_value_columns.freeze
+          @auto_validate_min_value_columns.freeze
           @auto_validate_unique_columns.freeze
 
           super
         end
 
         # Skip automatic validations for the given validation type
-        # (:not_null, :types, :unique, :max_length, :no_null_byte).
+        # (:not_null, :no_null_byte, :types, :unique, :max_length, :max_value, :min_value).
         # If :all is given as the type, skip all auto validations.
+        #
+        # Skipping types validation automatically skips max_value and min_value validations,
+        # since those validations require valid types.
         def skip_auto_validations(type)
           case type
           when :all
-            [:not_null, :no_null_byte, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
+            [:not_null, :no_null_byte, :types, :unique, :max_length, :max_value, :min_value].each{|v| skip_auto_validations(v)}
           when :not_null
             auto_validate_not_null_columns.clear
             auto_validate_explicit_not_null_columns.clear
@@ -199,6 +223,8 @@ module Sequel
           explicit_not_null_cols += Array(primary_key)
           @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq
           @auto_validate_max_length_columns = db_schema.select{|col, sch| sch[:type] == :string && sch[:max_length].is_a?(Integer)}.map{|col, sch| [col, sch[:max_length]]}
+          @auto_validate_max_value_columns = db_schema.select{|col, sch| sch[:max_value]}.map{|col, sch| [col, sch[:max_value]]}
+          @auto_validate_min_value_columns = db_schema.select{|col, sch| sch[:min_value]}.map{|col, sch| [col, sch[:min_value]]}
           @auto_validate_no_null_byte_columns = db_schema.select{|_, sch| sch[:type] == :string}.map{|col, _| col}
           table = dataset.first_source_table
           @auto_validate_unique_columns = if db.supports_index_parsing? && [Symbol, SQL::QualifiedIdentifier, SQL::Identifier, String].any?{|c| table.is_a?(c)}
@@ -248,6 +274,18 @@ module Sequel
 
           unless skip.include?(:types) || !model.auto_validate_types?
             validates_schema_types(keys, opts[:schema_types])
+
+            unless skip.include?(:max_value) || ((max_value_columns = model.auto_validate_max_value_columns).empty?)
+              max_value_columns.each do |col, max|
+                validates_max_value(max, col, opts[:max_value])
+              end
+            end
+
+            unless skip.include?(:min_value) || ((min_value_columns = model.auto_validate_min_value_columns).empty?)
+              min_value_columns.each do |col, min|
+                validates_min_value(min, col, opts[:min_value])
+              end
+            end
           end
 
           unless skip.include?(:unique)

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -104,7 +104,7 @@ module Sequel
     # should reference the subquery alias (and qualified identifiers should not be needed
     # unless joining to another table):
     #
-    #   a = Executive.where(:id=>1).first # works
+    #   a = Executive.where(id: 1).first # works
     #   a = Executive.where{{employees[:id]=>1}}.first # works
     #   a = Executive.where{{executives[:id]=>1}}.first # doesn't work
     #
@@ -115,7 +115,7 @@ module Sequel
     #
     #   pks = Executive.where{num_staff < 10}.select_map(:id)
     #   Executive.cti_tables.reverse_each do |table|
-    #     DB.from(table).where(:id=>pks).delete
+    #     DB.from(table).where(id: pks).delete
     #   end
     #
     # = Usage

data/lib/sequel/plugins/column_encryption.rb

@@ -31,7 +31,6 @@ rescue RuntimeError, OpenSSL::Cipher::CipherError
   # :nocov:
 end
 
-require 'base64'
 require 'securerandom'
 
 module Sequel
@@ -326,7 +325,7 @@ module Sequel
     #   DB.alter_table(:ce_test) do
     #     c = Sequel[:encrypted_column_name]
     #     add_constraint(:enc_base64) do
-    #       octet_length(decode(regexp_replace(regexp_replace(c, '_', '/', 'g'), '-', '+', 'g'), 'base64')) >= 65}
+    #       octet_length(decode(regexp_replace(regexp_replace(c, '_', '/', 'g'), '-', '+', 'g'), 'base64')) >= 65
     #     end
     #   end
     #
@@ -375,7 +374,7 @@ module Sequel
         # Decrypt using any supported format and any available key.
         def decrypt(data)
           begin
-            data = Base64.urlsafe_decode64(data)
+            data = urlsafe_decode64(data)
           rescue ArgumentError
             raise Error, "Unable to decode encrypted column: invalid base64"
           end
@@ -448,7 +447,7 @@ module Sequel
         # The prefix string of columns for the given search type and the first configured encryption key.
         # Used to find values that do not use this prefix in order to perform reencryption.
         def current_key_prefix(search_type)
-          Base64.urlsafe_encode64("#{search_type.chr}\0#{@key_id.chr}")
+          urlsafe_encode64("#{search_type.chr}\0#{@key_id.chr}")
         end
 
         # The prefix values to search for the given data (an array of strings), assuming the column uses
@@ -472,11 +471,33 @@ module Sequel
 
         private
 
+        if RUBY_VERSION >= '2.4'
+          def decode64(str)
+            str.unpack1("m0")
+          end
+        # :nocov:
+        else
+          def decode64(str)
+            str.unpack("m0")[0]
+          end
+        # :nocov:
+        end
+
+        def urlsafe_encode64(bin)
+          str = [bin].pack("m0")
+          str.tr!("+/", "-_")
+          str
+        end
+
+        def urlsafe_decode64(str)
+          decode64(str.tr("-_", "+/"))
+        end
+
         # An array of strings, one for each configured encryption key, to find encypted values matching
         # the given data and search format.
         def _search_prefixes(data, search_type)
           @key_map.map do |key_id, (key, _)|
-            Base64.urlsafe_encode64(_search_prefix(data, search_type, key_id, key))
+            urlsafe_encode64(_search_prefix(data, search_type, key_id, key))
           end
         end
 
@@ -509,7 +530,7 @@ module Sequel
           cipher_text << cipher.update(data) if data_size > 0
           cipher_text << cipher.final
 
-          Base64.urlsafe_encode64("#{prefix}#{random_data}#{cipher_iv}#{cipher.auth_tag}#{cipher_text}")
+          urlsafe_encode64("#{prefix}#{random_data}#{cipher_iv}#{cipher.auth_tag}#{cipher_text}")
         end
       end
 

data/lib/sequel/plugins/composition.rb

@@ -39,8 +39,8 @@ module Sequel
     # also be implemented as:
     #
     #   Album.composition :date,
-    #     :composer=>proc{Date.new(year, month, day) if year || month || day},
-    #     :decomposer=>(proc do
+    #     composer: proc{Date.new(year, month, day) if year || month || day},
+    #     decomposer: (proc do
     #       if d = compositions[:date]
     #         self.year = d.year
     #         self.month = d.month

data/lib/sequel/plugins/concurrent_eager_loading.rb

@@ -50,10 +50,10 @@ module Sequel
     # support concurrent eager loading.  Taking this example from the
     # {Advanced Associations guide}[rdoc-ref:doc/advanced_associations.rdoc]
     #
-    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #   Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     #     eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     #     id_map = eo_opts[:id_map]
-    #     Artist.where(:id=>id_map.keys).all do |artist|
+    #     Artist.where(id: id_map.keys).all do |artist|
     #       if albums = id_map[artist.id]
     #         albums.each do |album|
     #           album.associations[:artist] = artist
@@ -74,12 +74,12 @@ module Sequel
     # the code that loads the objects, since that will prevent concurrent loading.
     # So after the changes, the custom eager loader would look like this:
     #
-    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #   Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     #     Sequel.synchronize_with(eo[:mutex]) do
     #       eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     #     end
     #     id_map = eo_opts[:id_map]
-    #     rows = Artist.where(:id=>id_map.keys).all
+    #     rows = Artist.where(id: id_map.keys).all
     #     Sequel.synchronize_with(eo[:mutex]) do
     #       rows.each do |artist|
     #         if albums = id_map[artist.id]

data/lib/sequel/plugins/constraint_validations.rb

@@ -125,14 +125,15 @@ module Sequel
             ds = @dataset.with_quote_identifiers(false)
             table_name = ds.literal(ds.first_source_table)
             reflections = {}
-            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections)}
+            allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
+            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
             @constraint_validation_reflections = reflections
           end
         end
 
         # Given a specific database constraint validation metadata row hash, transform
         # it in an validation method call array suitable for splatting to send.
-        def constraint_validation_array(r, reflections)
+        def constraint_validation_array(r, reflections, allow_missing_columns=EMPTY_ARRAY)
           opts = {}
           opts[:message] = r[:message] if r[:message]
           opts[:allow_nil] = true if db.typecast_value(:boolean, r[:allow_nil])
@@ -191,11 +192,13 @@ module Sequel
             reflection_opts[:argument] = arg
           end 
 
-          a << column
-          unless opts.empty?
-            a << opts
+          opts[:from] = :values
+          if column.is_a?(Symbol) && allow_missing_columns.include?(column)
+            opts[:allow_missing] = true
           end
 
+          a << column << opts
+
           if column.is_a?(Array) && column.length == 1
             column = column.first
           end

data/lib/sequel/plugins/defaults_setter.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require 'delegate'
+
 module Sequel
   module Plugins
     # The defaults_setter plugin makes the column getter methods return the default
@@ -106,6 +108,20 @@ module Sequel
             lambda{Date.today}
           when Sequel::CURRENT_TIMESTAMP
             lambda{dataset.current_datetime}
+          when Hash, Array
+            v = Marshal.dump(v).freeze
+            lambda{Marshal.load(v)}
+          when Delegator
+            # DelegateClass returns an anonymous case, which cannot be marshalled, so marshal the
+            # underlying object and create a new instance of the class with the unmarshalled object.
+            klass = v.class
+            case o = v.__getobj__
+            when Hash, Array
+              v = Marshal.dump(o).freeze
+              lambda{klass.new(Marshal.load(v))}
+            else
+              v
+            end
           else
             v
           end

data/lib/sequel/plugins/dirty.rb

@@ -37,7 +37,7 @@ module Sequel
     #
     # It also saves the previously changed values after an update:
     #
-    #   artist.update(:name=>'Bar')
+    #   artist.update(name: 'Bar')
     #   artist.column_changes        # => {}
     #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
     #

data/lib/sequel/plugins/finder.rb

@@ -97,7 +97,9 @@ module Sequel
         #   Artist.first_by_name(nil)
         #   # WHERE (name IS NULL)
         #
-        # See Dataset::PlaceholderLiteralizer for additional caveats.
+        # See Dataset::PlaceholderLiteralizer for additional caveats. Note that if the model's
+        # dataset does not support placeholder literalizers, you will not be able to use this
+        # method.
         def finder(meth=OPTS, opts=OPTS, &block)
           if block
             raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
@@ -149,7 +151,7 @@ module Sequel
                 ds
               end
 
-              Sequel::Dataset::PlaceholderLiteralizer.loader(model, &block) 
+              model.dataset.placeholder_literalizer_class.loader(model, &block) 
             end
           end
 

data/lib/sequel/plugins/list.rb

@@ -33,7 +33,9 @@ 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:
@@ -183,10 +185,13 @@ module Sequel
         end
 
         # Set the value of the position_field to the maximum value plus 1 unless the
-        # position field already has a value.
+        # position field already has a value. If the list is empty, the position will
+        # be set to the model's +top_of_list+ value.
         def before_validation
           unless get_column_value(position_field)
-            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
+            current_max = list_dataset.max(position_field)
+            value = current_max.nil? ? model.top_of_list : current_max.to_i + 1
+            set_column_value("#{position_field}=", value)
           end
           super
         end

data/lib/sequel/plugins/many_through_many.rb

@@ -385,7 +385,7 @@ module Sequel
                 iq = nil
               end
               fe = opts.final_edge
-              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)
+              ds.graph(eager_graph_dataset(opts, eo), 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