sequel 3.11.0 → 3.12.0

data/lib/sequel/extensions/schema_dumper.rb

@@ -13,12 +13,12 @@ module Sequel
     def dump_indexes_migration(options={})
       ts = tables(options)
       <<END_MIG
-Class.new(Sequel::Migration) do
-  def up
+Sequel.migration do
+  up do
 #{ts.sort_by{|t| t.to_s}.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
   end
   
-  def down
+  down do
 #{ts.sort_by{|t| t.to_s}.map{|t| dump_table_indexes(t, :drop_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
   end
 end
@@ -37,12 +37,12 @@ END_MIG
     def dump_schema_migration(options={})
       ts = tables(options)
       <<END_MIG
-Class.new(Sequel::Migration) do
-  def up
+Sequel.migration do
+  up do
 #{ts.sort_by{|t| t.to_s}.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/o, '    ')}
   end
   
-  def down
+  down do
     drop_table(#{ts.sort_by{|t| t.to_s}.inspect[1...-1]})
   end
 end
@@ -52,12 +52,18 @@ END_MIG
     # Return a string with a create table block that will recreate the given
     # table's schema.  Takes the same options as dump_schema_migration.
     def dump_table_schema(table, options={})
+      table = table.value.to_s if table.is_a?(SQL::Identifier)
+      raise(Error, "must provide table as a Symbol, String, or Sequel::SQL::Identifier") unless [String, Symbol].any?{|c| table.is_a?(c)}
       s = schema(table).dup
       pks = s.find_all{|x| x.last[:primary_key] == true}.map{|x| x.first}
       options = options.merge(:single_pk=>true) if pks.length == 1
       m = method(:column_schema_to_generator_opts)
       im = method(:index_to_generator_opts)
-      indexes = indexes(table).sort_by{|k,v| k.to_s} if options[:indexes] != false and respond_to?(:indexes)
+      begin
+        indexes = indexes(table).sort_by{|k,v| k.to_s} if options[:indexes] != false
+      rescue Sequel::NotImplemented
+        nil
+      end
       gen = Schema::Generator.new(self) do
         s.each{|name, info| send(*m.call(name, info, options))}
         primary_key(pks) if !@primary_key && pks.length > 0
@@ -128,8 +134,8 @@ END_MIG
         {:type=>Date}
       when /\A(?:small)?datetime\z/o
         {:type=>DateTime}
-      when /\Atimestamp(?: with(?:out)? time zone)?\z/o
-        {:type=>DateTime}
+      when /\Atimestamp(?:\((\d+)\))?(?: with(?:out)? time zone)?\z/o
+        {:type=>DateTime, :size=>($1.to_i if $1)}
       when /\Atime(?: with(?:out)? time zone)?\z/o
         {:type=>Time, :only_time=>true}
       when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
@@ -208,7 +214,7 @@ END_MIG
       # Dump this generator's constraints to a string that could be evaled inside
       # another instance to represent the same constraints
       def dump_constraints
-        constraints.map do |c|
+        cs = constraints.map do |c|
           c = c.dup
           type = c.delete(:type)
           case type
@@ -224,7 +230,8 @@ END_MIG
             cols = c.delete(:columns)
             "#{type} #{cols.inspect}#{opts_inspect(c)}"
           end
-        end.join("\n")
+        end
+        cs.join("\n")
       end
 
       # Dump this generator's indexes to a string that could be evaled inside
@@ -235,7 +242,7 @@ END_MIG
       # * :drop_index - Same as add_index, but create drop_index statements.
       # * :ignore_errors - Add the ignore_errors option to the outputted indexes
       def dump_indexes(options={})
-        indexes.map do |c|
+        is = indexes.map do |c|
           c = c.dup
           cols = c.delete(:columns)
           if table = options[:add_index] || options[:drop_index]
@@ -243,7 +250,8 @@ END_MIG
           else
             "index #{cols.inspect}#{opts_inspect(c)}"
           end
-        end.join("\n")
+        end
+        is.join("\n")
       end
 
       private

data/lib/sequel/model.rb

@@ -44,28 +44,30 @@ module Sequel
     ANONYMOUS_MODEL_CLASSES = {}
 
     # Class methods added to model that call the method of the same name on the dataset
-    DATASET_METHODS = %w'<< add_graph_aliases all avg count cross_join delete distinct
-       each each_page each_server eager eager_graph empty? except exclude filter first for_update from from_self
-       full_join full_outer_join get graph grep group group_and_count group_by having import
-       inner_join insert insert_multiple intersect interval invert join join_table
-       last left_join left_outer_join limit lock_style map max min multi_insert naked
-       natural_full_join natural_join natural_left_join natural_right_join order order_by
-       order_more paginate print qualify query range reverse reverse_order right_join right_outer_join
-       select select_all select_append select_hash select_map select_more select_order_map
-       server set set_defaults set_graph_aliases set_overrides
-       single_value sum to_csv to_hash truncate unfiltered ungraphed ungrouped union unlimited unordered 
-       update where with with_recursive with_sql'.map{|x| x.to_sym}
-  
+    DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS +
+      [:eager, :eager_graph, :each_page, :each_server, :print]) - [:and, :or, :[], :[]=, :columns, :columns!]
+    
     # Class instance variables to set to nil when a subclass is created, for -w compliance
     EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@db]
 
+    # Boolean settings that can be modified at the global, class, or instance level.
+    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions]
+
+    # Hooks that are called before an action.  Can return false to not do the action.  When
+    # overriding these, it is recommended to call super as the last line of your method,
+    # so later hooks are called before earlier hooks.
+    BEFORE_HOOKS = [:before_create, :before_update, :before_save, :before_destroy, :before_validation]
+
+    # Hooks that are called after an action.  When overriding these, it is recommended to call
+    # super on the first line of your method, so later hooks are called before earlier hooks.
+    AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy, :after_validation]
+
     # Empty instance methods to create that the user can override to get hook/callback behavior.
     # Just like any other method defined by Sequel, if you override one of these, you should
     # call super to get the default behavior (while empty by default, they can also be defined
-    # by plugins).  
-    HOOKS = [:after_initialize, :before_create, :after_create, :before_update,
-      :after_update, :before_save, :after_save, :before_destroy, :after_destroy,
-      :before_validation, :after_validation]
+    # by plugins).  See the {"Model Hooks" guide}[link:files/doc/model_hooks_rdoc.html] for
+    # more detail on hooks.
+    HOOKS = BEFORE_HOOKS + AFTER_HOOKS
 
     # Class instance variables that are inherited in subclasses.  If the value is :dup, dup is called
     # on the superclass's instance variable when creating the instance variable in the subclass.
@@ -83,10 +85,6 @@ module Sequel
     # avoid problems when using eval with a string to define methods.
     NORMAL_METHOD_NAME_REGEXP = /\A[A-Za-z_][A-Za-z0-9_]*\z/
 
-    # The setter methods (methods ending with =) that are never allowed
-    # to be called automatically via set/update/new/etc..
-    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_empty_string_to_nil= typecast_on_assignment= strict_param_setting= raise_on_save_failure= raise_on_typecast_failure="
-
     # Regular expression that determines if the method is a valid setter name
     # (i.e. it ends with =).
     SETTER_METHOD_REGEXP = /=\z/
@@ -110,11 +108,15 @@ module Sequel
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
     @use_transactions = true
-  end
 
-  require %w"default_inflections inflections plugins base exceptions errors", "model"
-  if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
-    require 'associations', 'model'
-    Model.plugin Model::Associations
+    Sequel.require %w"default_inflections inflections plugins base exceptions errors", "model"
+    if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
+      Sequel.require 'associations', 'model'
+      plugin Model::Associations
+    end
+
+    # The setter methods (methods ending with =) that are never allowed
+    # to be called automatically via set/update/new/etc..
+    RESTRICTED_SETTER_METHODS = instance_methods.map{|x| x.to_s}.grep(SETTER_METHOD_REGEXP)
   end
 end

data/lib/sequel/model/associations.rb

@@ -310,6 +310,11 @@ module Sequel
           self[:join_table]
         end
         
+        # Alias of right_primary_keys
+        def associated_object_keys
+          right_primary_keys
+        end
+
         # many_to_many associations can only have associated objects if none of
         # the :left_primary_keys options have a nil value.
         def can_have_associated_objects?(obj)
@@ -380,7 +385,6 @@ module Sequel
         def right_primary_keys
           self[:right_primary_keys] ||= Array(right_primary_key)
         end
-        alias associated_object_keys right_primary_keys
     
         # The columns to select when loading the association, associated_class.table_name.* by default.
         def select
@@ -441,8 +445,8 @@ module Sequel
       #   => {:type => :many_to_one, :name => :portfolio, :class_name => "Portfolio"}
       #
       # For a more in depth general overview, as well as a reference guide,
-      # see the {Association Basics page}[link:files/doc/association_basics_rdoc.html].
-      # For examples of advanced usage, see the {Advanced Associations page}[link:files/doc/advanced_associations_rdoc.html].
+      # see the {Association Basics guide}[link:files/doc/association_basics_rdoc.html].
+      # For examples of advanced usage, see the {Advanced Associations guide}[link:files/doc/advanced_associations_rdoc.html].
       module ClassMethods
         # All association reflections defined for this model (default: none).
         attr_reader :association_reflections
@@ -521,9 +525,11 @@ module Sequel
         #     Takes three arguments, a dataset, an alias to use for the table to graph for this association,
         #     and the alias that was used for the current table (since you can cascade associations),
         #     Should return a copy of the dataset with the association graphed into it.
-        #   - :eager_loader - A proc to use to implement eager loading, overriding the default.  Takes three arguments,
-        #     a key hash (used solely to enhance performance), an array of records,
-        #     and a hash of dependent associations.  The associated records should
+        #   - :eager_loader - A proc to use to implement eager loading, overriding the default.  Takes one or three arguments.
+        #     If three arguments, the first should be a key hash (used solely to enhance performance), the second an array of records,
+        #     and the third a hash of dependent associations. If one argument, is passed a hash with keys :key_hash,
+        #     :rows, and :associations, corresponding to the three arguments, and an additional key :self, which is
+        #     the dataset doing the eager loading. In the proc, the associated records should
         #     be queried from the database and the associations cache for each
         #     record should be populated for this to work correctly.
         #   - :eager_loader_key - A symbol for the key column to use to populate the key hash
@@ -593,6 +599,8 @@ module Sequel
         #     the current model and the associated model, as a symbol.  Defaults to the name
         #     of current model and name of associated model, pluralized,
         #     underscored, sorted, and joined with '_'.
+        #   - :join_table_block - proc that can be used to modify the dataset used in the add/remove/remove_all
+        #     methods.  Should accept a dataset argument and return a modified dataset if present.
         #   - :left_key - foreign key in join table that points to current model's
         #     primary key, as a symbol. Defaults to :"#{self.name.underscore}_id".  
         #     Can use an array of symbols for a composite key association.
@@ -610,6 +618,7 @@ module Sequel
           raise(Error, 'one_to_many association type with :one_to_one option removed, used one_to_one association type') if opts[:one_to_one] && type == :one_to_many
           raise(Error, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
           raise(Error, 'Model.associate name argument must be a symbol') unless Symbol === name
+          raise(Error, ':eager_loader option must have an arity of 1 or 3') if opts[:eager_loader] && ![1, 3].include?(opts[:eager_loader].arity)
       
           # merge early so we don't modify opts
           orig_opts = opts.dup
@@ -649,7 +658,7 @@ module Sequel
         end
 
         # Modify and return eager loading dataset based on association options. Options:
-        def eager_loading_dataset(opts, ds, select, associations)
+        def eager_loading_dataset(opts, ds, select, associations, eager_options={})
           ds = ds.select(*select) if select
           if c = opts[:conditions]
             ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
@@ -757,12 +766,12 @@ module Sequel
           opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, rcks.zip(opts.right_primary_keys) + lcks.zip(lcpks.map{|k| send(k)}))}
           database = db
           
-          opts[:eager_loader] ||= proc do |key_hash, records, associations|
-            h = key_hash[left_pk]
-            records.each{|object| object.associations[name] = []}
+          opts[:eager_loader] ||= proc do |eo|
+            h = eo[:key_hash][left_pk]
+            eo[:rows].each{|object| object.associations[name] = []}
             r = uses_rcks ? rcks.zip(opts.right_primary_keys) : [[right, opts.right_primary_key]]
             l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, SQL::SQLArray.new(h.keys)]] : [[left, h.keys]]
-            model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), Array(opts.select), associations).all do |assoc_record|
+            model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), Array(opts.select), eo[:associations], eo).all do |assoc_record|
               hash_key = if uses_lcks
                 left_key_alias.map{|k| assoc_record.values.delete(k)}
               else
@@ -796,13 +805,13 @@ module Sequel
             h = {}
             lcks.zip(lcpks).each{|k, pk| h[k] = send(pk)}
             rcks.zip(opts.right_primary_keys).each{|k, pk| h[k] = o.send(pk)}
-            database.dataset.from(join_table).insert(h)
+            _join_table_dataset(opts).insert(h)
           end
           association_module_private_def(opts._remove_method) do |o|
-            database.dataset.from(join_table).filter(lcks.zip(lcpks.map{|k| send(k)}) + rcks.zip(opts.right_primary_keys.map{|k| o.send(k)})).delete
+            _join_table_dataset(opts).filter(lcks.zip(lcpks.map{|k| send(k)}) + rcks.zip(opts.right_primary_keys.map{|k| o.send(k)})).delete
           end
           association_module_private_def(opts._remove_all_method) do
-            _apply_association_options(opts, database.dataset.from(join_table).filter(lcks.zip(lcpks.map{|k| send(k)}))).delete
+            _join_table_dataset(opts).filter(lcks.zip(lcpks.map{|k| send(k)})).delete
           end
       
           def_add_method(opts)
@@ -823,16 +832,16 @@ module Sequel
             klass = opts.associated_class
             klass.filter(opts.primary_keys.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}.zip(cks.map{|k| send(k)}))
           end
-          opts[:eager_loader] ||= proc do |key_hash, records, associations|
-            h = key_hash[key]
+          opts[:eager_loader] ||= proc do |eo|
+            h = eo[:key_hash][key]
             keys = h.keys
             # Default the cached association to nil, so any object that doesn't have it
             # populated will have cached the negative lookup.
-            records.each{|object| object.associations[name] = nil}
+            eo[:rows].each{|object| object.associations[name] = nil}
             # Skip eager loading if no objects have a foreign key for this association
             unless keys.empty?
               klass = opts.associated_class
-              model.eager_loading_dataset(opts, klass.filter(uses_cks ? {opts.primary_keys.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>SQL::SQLArray.new(keys)} : {SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>keys}), opts.select, associations).all do |assoc_record|
+              model.eager_loading_dataset(opts, klass.filter(uses_cks ? {opts.primary_keys.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>SQL::SQLArray.new(keys)} : {SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>keys}), opts.select, eo[:associations], eo).all do |assoc_record|
                 hash_key = uses_cks ? opts.primary_keys.map{|k| assoc_record.send(k)} : assoc_record.send(opts.primary_key)
                 next unless objects = h[hash_key]
                 objects.each{|object| object.associations[name] = assoc_record}
@@ -873,16 +882,16 @@ module Sequel
             klass = opts.associated_class
             klass.filter(cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}.zip(cpks.map{|k| send(k)}))
           end
-          opts[:eager_loader] ||= proc do |key_hash, records, associations|
-            h = key_hash[primary_key]
+          opts[:eager_loader] ||= proc do |eo|
+            h = eo[:key_hash][primary_key]
             if one_to_one
-              records.each{|object| object.associations[name] = nil}
+              eo[:rows].each{|object| object.associations[name] = nil}
             else
-              records.each{|object| object.associations[name] = []}
+              eo[:rows].each{|object| object.associations[name] = []}
             end
             reciprocal = opts.reciprocal
             klass = opts.associated_class
-            model.eager_loading_dataset(opts, klass.filter(uses_cks ? {cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>SQL::SQLArray.new(h.keys)} : {SQL::QualifiedIdentifier.new(klass.table_name, key)=>h.keys}), opts.select, associations).all do |assoc_record|
+            model.eager_loading_dataset(opts, klass.filter(uses_cks ? {cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>SQL::SQLArray.new(h.keys)} : {SQL::QualifiedIdentifier.new(klass.table_name, key)=>h.keys}), opts.select, eo[:associations], eo).all do |assoc_record|
               hash_key = uses_cks ? cks.map{|k| assoc_record.send(k)} : assoc_record.send(key)
               next unless objects = h[hash_key]
               if one_to_one
@@ -928,11 +937,10 @@ module Sequel
                   up_ds = up_ds.exclude(o.pk_hash)
                   cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
                 end
-                update_database = lambda do
+                checked_transaction do
                   up_ds.update(ck_nil_hash)
                   o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save") if o
                 end
-                use_transactions && o ? db.transaction(opts){update_database.call} : update_database.call
               end
               association_module_def(opts.setter_method){|o| set_one_to_one_associated_object(opts, o)}
             else 
@@ -953,7 +961,11 @@ module Sequel
             end
           end
         end
-        alias def_one_to_one def_one_to_many
+
+        # Alias of def_one_to_many
+        def def_one_to_one(opts)
+          def_one_to_many(opts)
+        end
         
         # Add the remove_ and remove_all instance methods
         def def_remove_methods(opts)
@@ -1005,6 +1017,12 @@ module Sequel
           _apply_association_options(opts, send(opts._dataset_method))
         end
 
+        # Dataset for the join table of the given many to many association reflection
+        def _join_table_dataset(opts)
+          ds = model.db.from(opts[:join_table])
+          opts[:join_table_block] ? opts[:join_table_block].call(ds) : ds
+        end
+
         # Return the associated objects from the dataset, without callbacks, reciprocals, and caching.
         def _load_associated_objects(opts)
           if opts.returns_array?
@@ -1031,10 +1049,7 @@ module Sequel
             raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
           end
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") unless pk
-          if opts.need_associated_primary_key?
-            o.save(:validate=>opts[:validate]) if o.new?
-            raise(Sequel::Error, "associated object #{o.inspect} does not have a primary key") unless o.pk
-          end
+          ensure_associated_primary_key(opts, o, *args)
           return if run_association_callbacks(opts, :before_add, o) == false
           send(opts._add_method, o, *args)
           if array = associations[opts[:name]] and !array.include?(o)
@@ -1063,6 +1078,16 @@ module Sequel
           a.uniq!
         end
 
+        # Save the associated object if the associated object needs a primary key
+        # and the associated object is new and does not have one.  Raise an error if
+        # the object still does not have a primary key
+        def ensure_associated_primary_key(opts, o, *args)
+          if opts.need_associated_primary_key?
+            o.save(:validate=>opts[:validate]) if o.new?
+            raise(Sequel::Error, "associated object #{o.inspect} does not have a primary key") unless o.pk
+          end
+        end
+
         # Load the associated objects using the dataset, handling callbacks, reciprocals, and caching.
         def load_associated_objects(opts, reload=false)
           name = opts[:name]
@@ -1095,9 +1120,7 @@ module Sequel
         def remove_associated_object(opts, o, *args)
           klass = opts.associated_class
           if o.is_a?(Integer) || o.is_a?(String) || o.is_a?(Array)
-            key = o
-            pkh = klass.primary_key_hash(key)
-            raise(Sequel::Error, "no object with key(s) #{key} is currently associated to #{inspect}") unless o = (opts.remove_should_check_existing? ? send(opts.dataset_method) : klass).first(pkh)
+            o = remove_check_existing_object_from_pk(opts, o, *args)
           elsif !o.is_a?(klass)
             raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
           elsif opts.remove_should_check_existing? && send(opts.dataset_method).filter(o.pk_hash).empty?
@@ -1113,6 +1136,16 @@ module Sequel
           o
         end
 
+        # If necessary, check that the object from the associated table specified by the primary key
+        # is currently associated to the object.  If it is associated, return the object, otherwise
+        # raise an error.
+        def remove_check_existing_object_from_pk(opts, o, *args)
+          key = o
+          pkh = opts.associated_class.qualified_primary_key_hash(key)
+          raise(Sequel::Error, "no object with key(s) #{key.inspect} is currently associated to #{inspect}") unless o = send(opts.dataset_method).first(pkh)
+          o
+        end
+
         # Remove/unset the current object from/as the given object's reciprocal association.
         def remove_reciprocal_object(opts, o)
           return unless reciprocal = opts.reciprocal
@@ -1498,7 +1531,12 @@ module Sequel
           end
           
           reflections.each do |r|
-            r[:eager_loader].call(key_hash, a, eager_assoc[r[:name]])
+            loader = r[:eager_loader]
+            if loader.arity == 1
+              loader.call(:key_hash=>key_hash, :rows=>a, :associations=>eager_assoc[r[:name]], :self=>self)
+            else
+              loader.call(key_hash, a, eager_assoc[r[:name]])
+            end
             a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} unless r[:after_load].empty?
           end 
         end

data/lib/sequel/model/base.rb

@@ -113,6 +113,11 @@ module Sequel
       def dataset
         @dataset || raise(Error, "No dataset associated with #{self}")
       end
+
+      # Alias of set_dataset
+      def dataset=(ds)
+        set_dataset(ds)
+      end
     
       # Returns the database associated with the Model class.
       # If this model doesn't have a database associated with it,
@@ -236,6 +241,14 @@ module Sequel
           {key => value}
         end
       end
+
+      # Return a hash where the keys are qualified column references.  Uses the given
+      # qualifier if provided, or the table_name otherwise.
+      def qualified_primary_key_hash(value, qualifier=table_name)
+        h = primary_key_hash(value)
+        h.to_a.each{|k,v| h[SQL::QualifiedIdentifier.new(qualifier, k)] = h.delete(k)}
+        h
+      end
   
       # Restrict the setting of the primary key(s) inside new/set/update.  Because
       # this is the default, this only make sense to use in a subclass where the
@@ -299,7 +312,6 @@ module Sequel
         check_non_connection_error{@db_schema = (inherited ? superclass.db_schema : get_db_schema)}
         self
       end
-      alias dataset= set_dataset
     
       # Sets the primary key for this model. You can use either a regular 
       # or a composite primary key.
@@ -524,7 +536,7 @@ module Sequel
       private_class_method :class_attr_overridable, :class_attr_reader
 
       class_attr_reader :columns, :db, :primary_key, :db_schema
-      class_attr_overridable :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :strict_param_setting, :typecast_empty_string_to_nil, :typecast_on_assignment, :use_transactions
+      class_attr_overridable *BOOLEAN_SETTINGS
 
       # The hash of attribute values.  Keys are symbols with the names of the
       # underlying database columns.
@@ -576,11 +588,10 @@ module Sequel
         end
       end
   
-      # Compares model instances by values.
+      # Alias of eql?
       def ==(obj)
-        (obj.class == model) && (obj.values == @values)
+        eql?(obj)
       end
-      alias eql? ==
   
       # If pk is not nil, true only if the objects have the same class and pk.
       # If pk is nil, false.
@@ -632,6 +643,11 @@ module Sequel
         @values.each(&block)
       end
   
+      # Compares model instances by values.
+      def eql?(obj)
+        (obj.class == model) && (obj.values == @values)
+      end
+
       # Returns the validation errors associated with this object.
       def errors
         @errors ||= Errors.new
@@ -772,6 +788,13 @@ module Sequel
         set_restricted(hash, false, except.flatten)
       end
   
+      # For each of the fields in the given array +fields+, call the setter
+      # method with the value of that +hash+ entry for the field. Returns self.
+      def set_fields(hash, fields)
+        fields.each{|f| send("#{f}=", hash[f])}
+        self
+      end
+  
       # Set the values using the entries in the hash, only if the key
       # is included in only.
       def set_only(hash, *only)
@@ -800,6 +823,13 @@ module Sequel
         update_restricted(hash, false, except.flatten)
       end
   
+      # Update the instances values by calling +set_fields+ with the +hash+
+      # and +fields+, then save any changes to the record.  Returns self.
+      def update_fields(hash, fields)
+        set_fields(hash, fields)
+        save_changes
+      end
+
       # Update the values using the entries in the hash, only if the key
       # is included in only.
       def update_only(hash, *only)
@@ -808,7 +838,8 @@ module Sequel
       
       # Validates the object.  If the object is invalid, errors should be added
       # to the errors attribute.  By default, does nothing, as all models
-      # are valid by default.
+      # are valid by default.  See the {"Model Validations" guide}[link:files/doc/validations_rdoc.html].
+      # for details about validation.
       def validate
       end
 
@@ -855,8 +886,10 @@ module Sequel
         delete
       end
 
+      # Insert the record into the database, returning the primary key if
+      # the record should be refreshed from the database.
       def _insert
-        ds = model.dataset
+        ds = _insert_dataset
         if ds.respond_to?(:insert_select) and h = ds.insert_select(@values)
           @values = h
           nil
@@ -871,6 +904,12 @@ module Sequel
         end
       end
       
+      # The dataset to use when inserting a new object.   The same as the model's
+      # dataset by default.
+      def _insert_dataset
+        model.dataset
+      end
+  
       # Refresh using a particular dataset, used inside save to make sure the same server
       # is used for reading newly inserted values from the database
       def _refresh(dataset)
@@ -886,30 +925,28 @@ module Sequel
         if new?
           return save_failure(:create) if before_create == false
           pk = _insert
-          @this = nil if pk
+          @this = nil
           @new = false
           @was_new = true
           after_create
           after_save
           @was_new = nil
-          if pk
-            ds = this
-            ds = ds.server(:default) unless ds.opts[:server]
-            _refresh(ds)
-          else
-            changed_columns.clear
-          end
+          pk ? _save_refresh : changed_columns.clear
         else
           return save_failure(:update) if before_update == false
           if columns.empty?
-            @columns_updated = opts[:changed] ? @values.reject{|k,v| !changed_columns.include?(k)} : @values.dup
+            @columns_updated = if opts[:changed]
+              @values.reject{|k,v| !changed_columns.include?(k)}
+            else
+              _save_update_all_columns_hash
+            end
             changed_columns.clear
           else # update only the specified columns
             @columns_updated = @values.reject{|k, v| !columns.include?(k)}
             changed_columns.reject!{|c| columns.include?(c)}
           end
-          Array(primary_key).each{|x| @columns_updated.delete(x)}
           _update(@columns_updated) unless @columns_updated.empty?
+          @this = nil
           after_update
           after_save
           @columns_updated = nil
@@ -917,6 +954,25 @@ module Sequel
         @modified = false
         self
       end
+
+      # Refresh the object after saving it, used to get
+      # default values of all columns.  Separated from _save so it
+      # can be overridden to avoid the refresh.
+      def _save_refresh
+        _refresh(this.opts[:server] ? this : this.server(:default))
+      end
+
+      # Return a hash of values used when saving all columns of an
+      # existing object (i.e. not passing specific columns to save
+      # or using update/save_changes).  Defaults to all of the
+      # object's values except unmodified primary key columns, as some
+      # databases don't like you setting primary key values even
+      # to their existing values.
+      def _save_update_all_columns_hash
+        v = @values.dup
+        Array(primary_key).each{|x| v.delete(x) unless changed_columns.include?(x)}
+        v
+      end
       
       # Update this instance's dataset with the supplied column hash.
       def _update(columns)
@@ -946,7 +1002,7 @@ module Sequel
       end
       
       # If transactions should be used, wrap the yield in a transaction block.
-      def checked_transaction(opts)
+      def checked_transaction(opts={})
         use_transaction?(opts) ? db.transaction(opts){yield} : yield
       end