sequel 3.33.0 → 3.34.0

data/lib/sequel/extensions/select_remove.rb

@@ -0,0 +1,35 @@
+# The select_remove extension adds Sequel::Dataset#select_remove for removing existing selected
+# columns from a dataset.  It's not part of Sequel core as it is rarely needed and has
+# some corner cases where it can't work correctly.
+
+module Sequel
+  class Dataset
+    # Remove columns from the list of selected columns.  If any of the currently selected
+    # columns use expressions/aliases, this will remove selected columns with the given
+    # aliases.  It will also remove entries from the selection that match exactly:
+    #
+    #   # Assume columns a, b, and c in items table
+    #   DB[:items] # SELECT * FROM items
+    #   DB[:items].select_remove(:c) # SELECT a, b FROM items
+    #   DB[:items].select(:a, :b___c, :c___b).select_remove(:c) # SELECT a, c AS b FROM items
+    #   DB[:items].select(:a, :b___c, :c___b).select_remove(:c___b) # SELECT a, b AS c FROM items
+    #
+    # Note that there are a few cases where this method may not work correctly:
+    #
+    # * This dataset joins multiple tables and does not have an existing explicit selection.
+    #   In this case, the code will currently use unqualified column names for all columns
+    #   the dataset returns, except for the columns given.
+    # * This dataset has an existing explicit selection containing an item that returns
+    #   multiple database columns (e.g. :table.*, 'column1, column2'.lit).  In this case,
+    #   the behavior is undefined and this method should not be used.
+    #
+    # There may be other cases where this method does not work correctly, use it with caution.
+    def select_remove(*cols)
+      if (sel = @opts[:select]) && !sel.empty?
+        select(*(columns.zip(sel).reject{|c, s| cols.include?(c)}.map{|c, s| s} - cols))
+      else
+        select(*(columns - cols))
+      end
+    end
+  end
+end

data/lib/sequel/extensions/sql_expr.rb

@@ -1,6 +1,6 @@
 # The sql_expr extension adds the sql_expr method to every object, which
-# returns an object that works nicely with Sequel's DSL.  This is
-# best shown by example:
+# returns an wrapped object that works nicely with Sequel's DSL by calling
+# Sequel.expr:
 #
 #   1.sql_expr < :a     # 1 < a
 #   false.sql_expr & :a # FALSE AND a
@@ -8,115 +8,9 @@
 #   ~nil.sql_expr       # NOT NULL
 #   "a".sql_expr + "b"  # 'a' || 'b'
 
-module Sequel
-  module SQL
-    # The GenericComplexExpression acts like a 
-    # GenericExpression in terms of methods,
-    # but has an internal structure of a
-    # ComplexExpression.  It is used by Object#sql_expr.
-    # Since we don't know what specific type of object
-    # we are dealing with it, we treat it similarly to
-    # how we treat symbols or literal strings, allowing
-    # many different types of methods.
-    class GenericComplexExpression < ComplexExpression
-      include AliasMethods
-      include BooleanMethods
-      include CastMethods
-      include ComplexExpressionMethods
-      include InequalityMethods
-      include NumericMethods
-      include OrderMethods
-      include StringMethods
-      include SubscriptMethods
-    end
-  end
-end
-
 class Object
-  # Return a copy of the object wrapped in a
-  # Sequel::SQL::GenericComplexExpression.  Allows easy use
-  # of the Object with Sequel's DSL.  You'll probably have
-  # to make sure that Sequel knows how to literalize the
-  # object properly, though.
-  def sql_expr
-    Sequel::SQL::GenericComplexExpression.new(:NOOP, self)
-  end
-end
-
-class FalseClass
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::BooleanExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   false.sql_expr & :a  # FALSE AND a
-  def sql_expr
-    Sequel::SQL::BooleanExpression.new(:NOOP, self)
-  end
-end
-
-class NilClass
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::BooleanExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   ~nil.sql_expr  # NOT NULL
-  def sql_expr
-    Sequel::SQL::BooleanExpression.new(:NOOP, self)
-  end
-end
-
-class Numeric
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::NumericExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   1.sql_expr < :a  # 1 < a
-  def sql_expr
-    Sequel::SQL::NumericExpression.new(:NOOP, self)
-  end
-end
-
-class Proc
-  # Evaluates the proc as a virtual row block.
-  # If a hash or array of two element arrays is returned,
-  # they are converted to a Sequel::SQL::BooleanExpression.  Otherwise,
-  # unless the object returned is already an Sequel::SQL::Expression,
-  # convert the object to an Sequel::SQL::GenericComplexExpression.
-  #
-  #   proc{a(b)}.sql_expr + 1  # a(b) + 1
-  #   proc{{a=>b}}.sql_expr | true  # (a = b) OR TRUE
-  #   proc{1}.sql_expr + :a  # 1 + a
-  def sql_expr
-    o = Sequel.virtual_row(&self)
-    if Sequel.condition_specifier?(o)
-      Sequel::SQL::BooleanExpression.from_value_pairs(o, :AND)
-    elsif o.is_a?(Sequel::SQL::Expression)
-      o
-    else
-      Sequel::SQL::GenericComplexExpression.new(:NOOP, o)
-    end
-  end
-end
-
-class String
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::StringExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   "a".sql_expr + :a  # 'a' || a
+  # Return the object wrapper in an appropriate Sequel expression object.
   def sql_expr
-    Sequel::SQL::StringExpression.new(:NOOP, self)
+    Sequel.expr(self)
   end
 end
-
-class TrueClass
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::BooleanExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   true.sql_expr | :a  # TRUE OR a
-  def sql_expr
-    Sequel::SQL::BooleanExpression.new(:NOOP, self)
-  end
-end
-

data/lib/sequel/extensions/to_dot.rb

@@ -47,7 +47,7 @@ module Sequel
       @stack.push(@i)
       case e
       when LiteralString
-        dot "#{e.inspect}.lit"
+        dot "#{e.inspect}.lit" # core_sql use
       when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
         dot e.inspect
       when Array

data/lib/sequel/model.rb

@@ -35,13 +35,18 @@ module Sequel
   #     dataset # => DB1[:comments]
   #   end
   def self.Model(source)
-    Model::ANONYMOUS_MODEL_CLASSES[source] ||= if source.is_a?(Database)
+    if Sequel::Model.cache_anonymous_models && (klass = Model::ANONYMOUS_MODEL_CLASSES[source])
+      return klass
+    end
+    klass = if source.is_a?(Database)
       c = Class.new(Model)
       c.db = source
       c
     else
       Class.new(Model).set_dataset(source)
     end
+    Model::ANONYMOUS_MODEL_CLASSES[source] = klass if Sequel::Model.cache_anonymous_models
+    klass
   end
 
   # <tt>Sequel::Model</tt> is an object relational mapper built on top of Sequel core.  Each
@@ -58,6 +63,9 @@ module Sequel
   # You can set the +SEQUEL_NO_ASSOCIATIONS+ constant or environment variable to
   # make Sequel not load the associations plugin by default.
   class Model
+    # Cache anonymous models created by Sequel::Model()
+    @cache_anonymous_models = true
+
     # Map that stores model classes created with <tt>Sequel::Model()</tt>, to allow the reopening
     # of classes when dealing with code reloading.
     ANONYMOUS_MODEL_CLASSES = {}
@@ -105,7 +113,8 @@ module Sequel
       :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
       :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
-      :@use_after_commit_rollback=>nil}
+      :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil,
+      :@fast_instance_delete_sql=>nil}
 
     # Regular expression that determines if a method name is normal in the sense that
     # it could be used literally in ruby code without using send.  Used to

data/lib/sequel/model/associations.rb

@@ -1373,6 +1373,14 @@ module Sequel
         def associations
           @associations ||= {}
         end
+
+        # Freeze the associations cache when freezing the object.  Note that
+        # retrieving associations after freezing will still work in most cases,
+        # but the associations will not be cached in the association cache.
+        def freeze
+          associations.freeze
+          super
+        end
       
         # Formally used internally by the associations code, like pk but doesn't raise
         # an Error if the model has no primary key.  Not used any longer, deprecated.
@@ -1424,15 +1432,29 @@ module Sequel
           opts[:join_table_block] ? opts[:join_table_block].call(ds) : ds
         end
 
+        # Return the associated single object for the given association reflection and dynamic options
+        # (or nil if no associated object).
+        def _load_associated_object(opts, dynamic_opts)
+          _load_associated_object_array(opts, dynamic_opts).first
+        end
+
+        # Load the associated objects for the given association reflection and dynamic options
+        # as an array.
+        def _load_associated_object_array(opts, dynamic_opts)
+          _associated_dataset(opts, dynamic_opts).all
+        end
+
         # Return the associated objects from the dataset, without association callbacks, reciprocals, and caching.
         # Still apply the dynamic callback if present.
         def _load_associated_objects(opts, dynamic_opts={})
-          if opts.returns_array?
-            opts.can_have_associated_objects?(self) ? _associated_dataset(opts, dynamic_opts).all : []
-          else
-            if opts.can_have_associated_objects?(self)
-              _associated_dataset(opts, dynamic_opts).all.first
+          if opts.can_have_associated_objects?(self)
+            if opts.returns_array?
+              _load_associated_object_array(opts, dynamic_opts)
+            else
+              _load_associated_object(opts, dynamic_opts)
             end
+          else
+            [] if opts.returns_array?
           end
         end
         
@@ -1466,6 +1488,7 @@ module Sequel
 
         # Add/Set the current object to/as the given object's reciprocal association.
         def add_reciprocal_object(opts, o)
+          return if o.frozen?
           return unless reciprocal = opts.reciprocal
           if opts.reciprocal_array?
             if array = o.associations[reciprocal] and !array.include?(self)
@@ -1514,9 +1537,14 @@ module Sequel
                 add_reciprocal_object(opts, objs)
               end
             end
-            associations[name] = objs
+
+            # If the current object is frozen, you can't update the associations
+            # cache.  This can cause issues for after_load procs that expect
+            # the objects to be already cached in the associations, but
+            # unfortunately that case cannot be handled.
+            associations[name] = objs unless frozen?
             run_association_callbacks(opts, :after_load, objs)
-            associations[name]
+            frozen? ? objs : associations[name]
           end
         end
 

data/lib/sequel/model/base.rb

@@ -13,6 +13,11 @@ module Sequel
       # Which columns should be the only columns allowed in a call to a mass assignment method (e.g. set)
       # (default: not set, so all columns not otherwise restricted are allowed).
       attr_reader :allowed_columns
+
+      # Whether to cache the anonymous models created by Sequel::Model().  This is
+      # required for reloading them correctly (avoiding the superclass mismatch).  True
+      # by default for backwards compatibility.
+      attr_accessor :cache_anonymous_models
   
       # Array of modules that extend this model's dataset.  Stored
       # so that if the model's dataset is changed, it will be extended
@@ -24,6 +29,14 @@ module Sequel
       # will be applied to the new dataset.
       attr_reader :dataset_methods
 
+      # SQL string fragment used for faster DELETE statement creation when deleting/destroying
+      # model instances, or nil if the optimization should not be used. For internal use only.
+      attr_reader :fast_instance_delete_sql
+
+      # The dataset that instance datasets (#this) are based on.  Generally a naked version of
+      # the model's dataset limited to one row.  For internal use only.
+      attr_reader :instance_dataset
+
       # Array of plugin modules loaded by this class
       #
       #   Sequel::Model.plugins
@@ -107,8 +120,8 @@ module Sequel
       #   Artist[:name=>'Bob'] # SELECT * FROM artists WHERE (name = 'Bob') LIMIT 1
       #   # => #<Artist {:name=>'Bob', ...}>
       def [](*args)
-        args = args.first if (args.size == 1)
-        args.is_a?(Hash) ? dataset[args] : primary_key_lookup(args)
+        args = args.first if args.size <= 1
+        args.is_a?(Hash) ? dataset[args] : (primary_key_lookup(args) unless args.nil?)
       end
 
       # Initializes a model instance as an existing record. This constructor is
@@ -394,7 +407,7 @@ module Sequel
       #   Artist.primary_key # => nil
       def no_primary_key
         clear_setter_methods_cache
-        @simple_pk = @primary_key = nil
+        self.simple_pk = @primary_key = nil
       end
       
       # Loads a plugin for use with the model class, passing optional arguments
@@ -402,16 +415,16 @@ module Sequel
       # require the plugin from either sequel/plugins/#{plugin} or
       # sequel_#{plugin}, and then attempt to load the module using a
       # the camelized plugin name under Sequel::Plugins.
-      def plugin(plugin, *args, &blk)
+      def plugin(plugin, *args, &block)
         m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
         unless @plugins.include?(m)
           @plugins << m
-          m.apply(self, *args, &blk) if m.respond_to?(:apply)
+          m.apply(self, *args, &block) if m.respond_to?(:apply)
           include(m::InstanceMethods) if plugin_module_defined?(m, :InstanceMethods)
           extend(m::ClassMethods)if plugin_module_defined?(m, :ClassMethods)
           dataset_extend(m::DatasetMethods) if plugin_module_defined?(m, :DatasetMethods)
         end
-        m.configure(self, *args, &blk) if m.respond_to?(:configure)
+        m.configure(self, *args, &block) if m.respond_to?(:configure)
       end
 
       # Returns primary key attribute hash.  If using a composite primary key
@@ -498,10 +511,10 @@ module Sequel
         inherited = opts[:inherited]
         @dataset = case ds
         when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, LiteralString
-          @simple_table = db.literal(ds)
+          self.simple_table = db.literal(ds)
           db.from(ds)
         when Dataset
-          @simple_table = if ds.send(:simple_select_all?)
+          self.simple_table = if ds.send(:simple_select_all?)
             ds.literal(ds.first_source_table)
           else
             nil
@@ -514,7 +527,7 @@ module Sequel
         @dataset.row_proc = self
         @require_modification = Sequel::Model.require_modification.nil? ? @dataset.provides_accurate_rows_matched? : Sequel::Model.require_modification
         if inherited
-          @simple_table = superclass.simple_table
+          self.simple_table = superclass.simple_table
           @columns = @dataset.columns rescue nil
         else
           @dataset_method_modules.each{|m| @dataset.extend(m)} if @dataset_method_modules
@@ -522,6 +535,7 @@ module Sequel
         end
         @dataset.model = self if @dataset.respond_to?(:model=)
         check_non_connection_error{@db_schema = (inherited ? superclass.db_schema : get_db_schema)}
+        @instance_dataset = @dataset.limit(1).naked
         self
       end
 
@@ -542,7 +556,7 @@ module Sequel
       def set_primary_key(*key)
         clear_setter_methods_cache
         key = key.flatten
-        @simple_pk = if key.length == 1
+        self.simple_pk = if key.length == 1
           (@dataset || db).literal(key.first)
         else 
           nil 
@@ -552,7 +566,7 @@ module Sequel
   
       # Set the columns to restrict when using mass assignment (e.g. +set+).  Using this means that
       # attempts to call setter methods for the columns listed here will cause an
-      # exception or be silently skipped (based on the +strict_param_setting+ setting.
+      # exception or be silently skipped (based on the +strict_param_setting+ setting).
       # If you have any virtual setter methods (methods that end in =) that you
       # want not to be used during mass assignment, they need to be listed here as well (without the =).
       #
@@ -769,13 +783,31 @@ module Sequel
   
       # Find the row in the dataset that matches the primary key.  Uses
       # a static SQL optimization if the table and primary key are simple.
+      #
+      # This method should not be called with a nil primary key, in case
+      # it is overridden by plugins which assume that the passed argument
+      # is valid.
       def primary_key_lookup(pk)
-        if t = simple_table and p = simple_pk
-          with_sql("SELECT * FROM #{t} WHERE #{p} = #{dataset.literal(pk)}").first
+        if sql = @fast_pk_lookup_sql
+          sql = sql.dup
+          dataset.literal_append(sql, pk)
+          dataset.fetch_rows(sql){|r| return call(r)}
+          nil
         else
           dataset[primary_key_hash(pk)]
         end
       end
+
+      # Reset the cached fast primary lookup SQL if a simple table and primary key
+      # are used, or set it to nil if not used.
+      def reset_fast_pk_lookup_sql
+        @fast_pk_lookup_sql = if @simple_table && @simple_pk
+          "SELECT * FROM #@simple_table WHERE #@simple_pk = ".freeze
+        end
+        @fast_instance_delete_sql = if @simple_table && @simple_pk
+          "DELETE FROM #@simple_table WHERE #@simple_pk = ".freeze
+        end
+      end
   
       # Set the columns for this model and create accessor methods for each column.
       def set_columns(new_columns)
@@ -784,6 +816,18 @@ module Sequel
         @columns
       end
 
+      # Reset the fast primary key lookup SQL when the simple_pk value changes.
+      def simple_pk=(pk)
+        @simple_pk = pk
+        reset_fast_pk_lookup_sql
+      end
+
+      # Reset the fast primary key lookup SQL when the simple_table value changes.
+      def simple_table=(t)
+        @simple_table = t
+        reset_fast_pk_lookup_sql
+      end
+
       # Add model methods that call dataset methods
       DATASET_METHODS.each{|arg| class_eval("def #{arg}(*args, &block); dataset.#{arg}(*args, &block) end", __FILE__, __LINE__)}
   
@@ -814,7 +858,7 @@ module Sequel
       # same name, caching the result in an instance variable.  Define
       # standard attr_writer method for modifying that instance variable.
       def self.class_attr_overridable(*meths) # :nodoc:
-        meths.each{|meth| class_eval("def #{meth}; !defined?(@#{meth}) ? (@#{meth} = self.class.#{meth}) : @#{meth} end", __FILE__, __LINE__)}
+        meths.each{|meth| class_eval("def #{meth}; !defined?(@#{meth}) ? (frozen? ? self.class.#{meth} : (@#{meth} = self.class.#{meth})) : @#{meth} end", __FILE__, __LINE__)}
         attr_writer(*meths) 
       end 
     
@@ -823,7 +867,7 @@ module Sequel
       #   
       #   define_method(meth){self.class.send(meth)}
       def self.class_attr_reader(*meths) # :nodoc:
-        meths.each{|meth| class_eval("def #{meth}; model.#{meth} end", __FILE__, __LINE__)}
+        meths.each{|meth| class_eval("def #{meth}; self.class.#{meth} end", __FILE__, __LINE__)}
       end
 
       private_class_method :class_attr_overridable, :class_attr_reader
@@ -888,9 +932,10 @@ module Sequel
         # If the column isn't in @values, we can't assume it is
         # NULL in the database, so assume it has changed.
         v = typecast_value(column, value)
-        if new? || !@values.include?(column) || v != (c = @values[column]) || v.class != c.class
+        vals = @values
+        if new? || !vals.include?(column) || v != (c = vals[column]) || v.class != c.class
           changed_columns << column unless changed_columns.include?(column)
-          @values[column] = v
+          vals[column] = v
         end
       end
   
@@ -941,6 +986,7 @@ module Sequel
       #   Artist[1].delete # DELETE FROM artists WHERE (id = 1)
       #   # => #<Artist {:id=>1, ...}>
       def delete
+        raise Sequel::Error, "can't delete frozen object" if frozen?
         _delete
         self
       end
@@ -955,6 +1001,7 @@ module Sequel
       #   Artist[1].destroy # BEGIN; DELETE FROM artists WHERE (id = 1); COMMIT;
       #   # => #<Artist {:id=>1, ...}>
       def destroy(opts = {})
+        raise Sequel::Error, "can't destroy frozen object" if frozen?
         checked_save_failure(opts){checked_transaction(opts){_destroy(opts)}}
       end
 
@@ -1002,6 +1049,19 @@ module Sequel
         @singleton_setter_added = true
         super
       end
+
+      # Freeze the object in such a way that it is still usable but not modifiable.
+      # Once an object is frozen, you cannot modify it's values, changed_columns,
+      # errors, or dataset.
+      def freeze
+        values.freeze
+        changed_columns.freeze
+        errors
+        validate
+        errors.freeze
+        this.freeze unless new?
+        super
+      end
   
       # Value that should be unique for objects with the same class and pk (if pk is not nil), or
       # the same class and values (if pk is nil).
@@ -1106,7 +1166,12 @@ module Sequel
       #   Artist[[1, 2]].pk # => [1, 2]
       def pk
         raise(Error, "No primary key is associated with this model") unless key = primary_key
-        key.is_a?(Array) ? key.map{|k| @values[k]} : @values[key]
+        if key.is_a?(Array)
+          vals = @values
+          key.map{|k| vals[k]}
+        else
+          @values[key]
+        end
       end
       
       # Returns a hash identifying mapping the receivers primary key column(s) to their values.
@@ -1126,6 +1191,7 @@ module Sequel
       #   a.refresh
       #   a.name # => 'Bob'
       def refresh
+        raise Sequel::Error, "can't refresh frozen object" if frozen?
         _refresh(this)
       end
 
@@ -1162,6 +1228,7 @@ module Sequel
       #                 +use_transactions+ setting
       # :validate :: set to false to skip validation
       def save(*columns)
+        raise Sequel::Error, "can't save frozen object" if frozen?
         opts = columns.last.is_a?(Hash) ? columns.pop : {}
         set_server(opts[:server]) if opts[:server] 
         if opts[:validate] != false
@@ -1220,14 +1287,56 @@ module Sequel
       # 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.
       #
+      # You can provide an options hash, with the following options currently respected:
+      # :missing :: Can be set to :skip to skip missing entries or :raise to raise an
+      #             Error for missing entries.  The default behavior is not to check for
+      #             missing entries, in which case the default value is used.  To be
+      #             friendly with most web frameworks, the missing check will also check
+      #             for the string version of the argument in the hash if given a symbol.
+      #
+      # Examples:
+      #
       #   artist.set_fields({:name=>'Jim'}, [:name])
       #   artist.name # => 'Jim'
       #
       #   artist.set_fields({:hometown=>'LA'}, [:name])
       #   artist.name # => nil
       #   artist.hometown # => 'Sac'
-      def set_fields(hash, fields)
-        fields.each{|f| send("#{f}=", hash[f])}
+      #
+      #   artist.name # => 'Jim'
+      #   artist.set_fields({}, [:name], :missing=>:skip)
+      #   artist.name # => 'Jim'
+      #
+      #   artist.name # => 'Jim'
+      #   artist.set_fields({}, [:name], :missing=>:raise)
+      #   # Sequel::Error raised
+      def set_fields(hash, fields, opts=nil)
+        if opts
+          case opts[:missing]
+          when :skip
+            fields.each do |f|
+              if hash.has_key?(f) 
+                send("#{f}=", hash[f])
+              elsif f.is_a?(Symbol) && hash.has_key?(sf = f.to_s)
+                send("#{sf}=", hash[sf])
+              end
+            end
+          when :raise
+            fields.each do |f|
+              if hash.has_key?(f)
+                send("#{f}=", hash[f])
+              elsif f.is_a?(Symbol) && hash.has_key?(sf = f.to_s)
+                send("#{sf}=", hash[sf])
+              else
+                raise(Sequel::Error, "missing field in hash: #{f.inspect} not in #{hash.inspect}")
+              end
+            end
+          else
+            fields.each{|f| send("#{f}=", hash[f])}
+          end
+        else
+          fields.each{|f| send("#{f}=", hash[f])}
+        end
         self
       end
   
@@ -1268,7 +1377,7 @@ module Sequel
       #   Artist[1].this
       #   # SELECT * FROM artists WHERE (id = 1) LIMIT 1
       def this
-        @this ||= use_server(model.dataset.filter(pk_hash).limit(1).naked)
+        @this ||= use_server(model.instance_dataset.filter(pk_hash))
       end
       
       # Runs #set with the passed hash and then runs save_changes.
@@ -1296,16 +1405,16 @@ 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.
+      # Update the instances values by calling +set_fields+ with the arguments, then
+      # saves any changes to the record.  Returns self.
       #
       #   artist.update_fields({:name=>'Jim'}, [:name])
       #   # UPDATE artists SET name = 'Jim' WHERE (id = 1)
       #
       #   artist.update_fields({:hometown=>'LA'}, [:name])
       #   # UPDATE artists SET name = NULL WHERE (id = 1)
-      def update_fields(hash, fields)
-        set_fields(hash, fields)
+      def update_fields(hash, fields, opts=nil)
+        set_fields(hash, fields, opts)
         save_changes
       end
 
@@ -1358,14 +1467,20 @@ module Sequel
       # Actually do the deletion of the object's dataset.  Return the
       # number of rows modified.
       def _delete_without_checking
-        _delete_dataset.delete
+        if sql = (m = model).fast_instance_delete_sql
+          sql = sql.dup
+          (ds = m.dataset).literal_append(sql, pk)
+          ds.with_sql_delete(sql)
+        else
+          _delete_dataset.delete 
+        end
       end
 
       # Internal destroy method, separted from destroy to
       # allow running inside a transaction
       def _destroy(opts)
         sh = {:server=>this_server}
-        db.after_rollback(sh){after_destroy_rollback} if use_after_commit_rollback
+        db.after_rollback(sh){after_destroy_rollback} if uacr = use_after_commit_rollback
         called = false
         around_destroy do
           called = true
@@ -1375,7 +1490,7 @@ module Sequel
           true
         end
         raise_hook_failure(:destroy) unless called
-        db.after_commit(sh){after_destroy_commit} if use_after_commit_rollback
+        db.after_commit(sh){after_destroy_commit} if uacr
         self
       end
       
@@ -1391,14 +1506,14 @@ module Sequel
       def _insert
         ds = _insert_dataset
         if !ds.opts[:select] and ds.supports_insert_select? and h = _insert_select_raw(ds)
-          @values = h
+          set_values(h)
           nil
         else
           iid = _insert_raw(ds)
           # if we have a regular primary key and it's not set in @values,
           # we assume it's the last inserted id
-          if (pk = autoincrementing_primary_key) && pk.is_a?(Symbol) && !@values[pk]
-            @values[pk] = iid
+          if (pk = autoincrementing_primary_key) && pk.is_a?(Symbol) && !(vals = @values)[pk]
+            vals[pk] = iid
           end
           pk
         end
@@ -1407,7 +1522,7 @@ module Sequel
       # The dataset to use when inserting a new object.   The same as the model's
       # dataset by default.
       def _insert_dataset
-        use_server(model.dataset)
+        use_server(model.instance_dataset)
       end
   
       # Insert into the given dataset and return the primary key created (if any).
@@ -1437,7 +1552,7 @@ module Sequel
       # it's own transaction.
       def _save(columns, opts)
         sh = {:server=>this_server}
-        db.after_rollback(sh){after_rollback} if use_after_commit_rollback
+        db.after_rollback(sh){after_rollback} if uacr = use_after_commit_rollback
         was_new = false
         pk = nil
         called_save = false
@@ -1491,7 +1606,7 @@ module Sequel
           @columns_updated = nil
         end
         @modified = false
-        db.after_commit(sh){after_commit} if use_after_commit_rollback
+        db.after_commit(sh){after_commit} if uacr
         self
       end
 
@@ -1544,6 +1659,7 @@ module Sequel
       # failures will be raised as HookFailure exceptions.  If it is
       # +false+, +false+ will be returned instead.
       def _valid?(raise_errors, opts)
+        return errors.empty? if frozen?
         errors.clear
         called = false
         error = false
@@ -1597,7 +1713,7 @@ module Sequel
       # exists so it can be overridden.  This is called only for new records, before
       # changed_columns is cleared.
       def initialize_set(h)
-        set(h)
+        set(h) unless h.empty?
       end
 
       # Default inspection output for the values hash, overwrite to change what #inspect displays.
@@ -1621,6 +1737,7 @@ module Sequel
   
       # Set the columns, filtered by the only and except arrays.
       def set_restricted(hash, only, except)
+        return self if hash.empty?
         meths = if only.nil? && except.nil? && !@singleton_setter_added
           model.setter_methods
         else
@@ -1679,7 +1796,13 @@ module Sequel
       # The server/shard that the model object's dataset uses, or :default if the
       # model object's dataset does not have an associated shard.
       def this_server
-        primary_key ? (this.opts[:server] || :default) : (model.dataset.opts[:server] || :default)
+        if (s = @server)
+          s
+        elsif (t = @this)
+          t.opts[:server] || :default
+        else
+          model.dataset.opts[:server] || :default
+        end
       end
   
       # Typecast the value to the column's type if typecasting.  Calls the database's