sequel 3.28.0 → 3.29.0

data/lib/sequel/extensions/named_timezones.rb

@@ -21,6 +21,11 @@
 # Then, before data is stored in the database, it is converted to New
 # York time.  When data is retrieved from the database, it is
 # converted to Los Angeles time.
+#
+# Note that typecasting from the database timezone to the application
+# timezone when fetching rows is dependent on the database adapter,
+# and only works on adapters where Sequel itself does the conversion.
+# It should work on mysql, postgres, sqlite, ibmdb, and jdbc.
 
 require 'tzinfo'
 

data/lib/sequel/extensions/thread_local_timezones.rb

@@ -32,7 +32,7 @@ module Sequel
   module ThreadLocalTimezones
     %w'application database typecast'.each do |t|
       class_eval("def thread_#{t}_timezone=(tz); Thread.current[:#{t}_timezone] = convert_timezone_setter_arg(tz); end", __FILE__, __LINE__)
-      class_eval(<<END, __FILE__, __LINE__)
+      class_eval(<<END, __FILE__, __LINE__ + 1)
         def #{t}_timezone
           if tz = Thread.current[:#{t}_timezone]
             tz unless tz == :nil

data/lib/sequel/model.rb

@@ -79,7 +79,8 @@ module Sequel
 
     # 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 after earlier hooks.
-    AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy, :after_validation]
+    AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy,
+      :after_validation, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]
 
     # Hooks that are called around an action.  If overridden, these methods must call super
     # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions

data/lib/sequel/model/associations.rb

@@ -127,6 +127,22 @@ module Sequel
         def need_associated_primary_key?
           false
         end
+
+        # Qualify +col+ with the given table name.  If +col+ is an array of columns,
+        # return an array of qualified columns.
+        def qualify(table, col)
+          transform(col){|k| SQL::QualifiedIdentifier.new(table, k)}
+        end
+
+        # Qualify col with the associated model's table name.
+        def qualify_assoc(col)
+          qualify(associated_class.table_name, col)
+        end
+        
+        # Qualify col with the current model's table name.
+        def qualify_cur(col)
+          qualify(self[:model].table_name, col)
+        end
         
         # Returns the reciprocal association variable, if one exists. The reciprocal
         # association is the association in the associated class that is the opposite
@@ -195,6 +211,14 @@ module Sequel
         def setter_method
           :"#{self[:name]}="
         end
+        
+        private
+
+        # If +s+ is an array, map +s+ over the block.  Otherwise, just call the
+        # block with +s+.
+        def transform(s)
+          s.is_a?(Array) ? s.map(&Proc.new) : (yield s)
+        end
       end
     
       class ManyToOneAssociationReflection < AssociationReflection
@@ -243,6 +267,11 @@ module Sequel
          self[:primary_keys] ||= Array(primary_key)
         end
         alias associated_object_keys primary_keys
+
+        # #primary_key qualified by the associated table
+        def qualified_primary_key
+          self[:qualified_primary_key] ||= self[:qualify] == false ? primary_key : qualify_assoc(primary_key)
+        end
         
         # True only if the reciprocal is a one_to_many association.
         def reciprocal_array?
@@ -297,12 +326,18 @@ module Sequel
 
         # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
         def eager_loading_predicate_key
-          self[:eager_loading_predicate_key] ||= self[:uses_composite_keys] ? self[:keys].map{|k| SQL::QualifiedIdentifier.new(associated_class.table_name, k)} : SQL::QualifiedIdentifier.new(associated_class.table_name, self[:key])
+          self[:eager_loading_predicate_key] ||= qualify_assoc(self[:key])
         end
+        alias qualified_key eager_loading_predicate_key
     
         # The column in the current table that the key in the associated table references.
         def primary_key
-         self[:primary_key] ||= self[:model].primary_key
+         self[:primary_key]
+        end
+
+        # #primary_key qualified by the current table
+        def qualified_primary_key
+          self[:qualified_primary_key] ||= qualify_cur(primary_key)
         end
       
         # Whether the reciprocal of this association returns an array of objects instead of a single object,
@@ -381,13 +416,6 @@ module Sequel
           self[:left_key]
         end
 
-        # The table containing the column to use for the associated key when eagerly loading
-        def associated_key_table
-          self[:associated_key_table] ||= (
-          syms = associated_class.dataset.split_alias(self[:join_table]);
-          syms[1] || syms[0])
-        end
-        
         # Alias of right_primary_keys
         def associated_object_keys
           right_primary_keys
@@ -427,9 +455,16 @@ module Sequel
           self[:eager_loader_key] ||= self[:left_primary_key]
         end
     
-        # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
+        # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3)).
+        # The left key qualified by the join table.
         def eager_loading_predicate_key
-          self[:eager_loading_predicate_key] ||= self[:uses_left_composite_keys] ? self[:left_keys].map{|k| SQL::QualifiedIdentifier.new(self[:join_table], k)} : SQL::QualifiedIdentifier.new(self[:join_table], self[:left_key])
+          self[:eager_loading_predicate_key] ||= qualify(join_table_alias, self[:left_key])
+        end
+        alias qualified_left_key eager_loading_predicate_key
+
+        # The right key qualified by the join table.
+        def qualified_right_key
+          self[:qualified_right_key] ||= qualify(join_table_alias, self[:right_key])
         end
     
         # many_to_many associations need to select a key in an associated table to eagerly load
@@ -437,6 +472,25 @@ module Sequel
           true
         end
 
+        # The source of the join table.  This is the join table itself, unless it
+        # is aliased, in which case it is the unaliased part.
+        def join_table_source
+          fetch(:join_table_source) do
+            split_join_table_alias
+            self[:join_table_source]
+          end
+        end
+
+        # The join table itself, unless it is aliased, in which case this
+        # is the alias.
+        def join_table_alias
+          fetch(:join_table_alias) do
+            split_join_table_alias
+            self[:join_table_alias]
+          end
+        end
+        alias associated_key_table join_table_alias
+        
         # Whether the associated object needs a primary key to be added/removed,
         # true for many_to_many associations.
         def need_associated_primary_key?
@@ -458,6 +512,11 @@ module Sequel
           end
           self[:reciprocal] = nil
         end
+
+        # #right_primary_key qualified by the associated table
+        def qualified_right_primary_key
+          self[:qualified_right_primary_key] ||= qualify_assoc(right_primary_key)
+        end
     
         # The primary key column(s) to use in the associated table (can be symbol or array).
         def right_primary_key
@@ -474,6 +533,15 @@ module Sequel
          return self[:select] if include?(:select)
          self[:select] ||= Sequel::SQL::ColumnAll.new(associated_class.table_name)
         end
+
+        private
+
+        # Split the join table into source and alias parts.
+        def split_join_table_alias
+          s, a = associated_class.dataset.split_alias(self[:join_table])
+          self[:join_table_source] = s
+          self[:join_table_alias] = a || s
+        end
       end
   
       # This module contains methods added to all association datasets
@@ -548,6 +616,22 @@ module Sequel
           association_reflections.values
         end
         
+        # Given an association reflection and a dataset, apply the
+        # :select, :conditions, :order, :eager, :distinct, and :eager_block
+        # association options to the given dataset and return the dataset
+        # or a modified copy of it.
+        def apply_association_dataset_opts(opts, ds)
+          ds = ds.select(*opts.select) if opts.select
+          if c = opts[:conditions]
+            ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+          end
+          ds = ds.order(*opts[:order]) if opts[:order]
+          ds = ds.eager(opts[:eager]) if opts[:eager]
+          ds = ds.distinct if opts[:distinct]
+          ds = opts[:eager_block].call(ds) if opts[:eager_block]
+          ds
+        end
+
         # Associates a related model with the current model. The following types are
         # supported:
         #
@@ -676,6 +760,10 @@ module Sequel
         # :primary_key :: column in the associated table that :key option references, as a symbol.
         #                 Defaults to the primary key of the associated table. Can use an
         #                 array of symbols for a composite key association.
+        # :qualify :: Whether to use qualifier primary keys when loading the association.  The default
+        #             is true, so you must set to false to not qualify.  Qualification rarely causes
+        #             problems, but it's necessary to disable in some cases, such as when you are doing
+        #             a JOIN USING operation on the column on Oracle.
         # === :one_to_many and :one_to_one
         # :key :: foreign key in associated model's table that references
         #         current model's primary key, as a symbol.  Defaults to
@@ -763,26 +851,19 @@ module Sequel
 
         # Modify and return eager loading dataset based on association options.
         def eager_loading_dataset(opts, ds, select, associations, eager_options={})
+          ds = apply_association_dataset_opts(opts, ds)
           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)
-          end
-          ds = ds.order(*opts[:order]) if opts[:order]
-          ds = ds.eager(opts[:eager]) if opts[:eager]
-          ds = ds.distinct if opts[:distinct]
           if opts[:eager_graph]
             raise(Error, "cannot eagerly load a #{opts[:type]} association that uses :eager_graph") if opts.eager_loading_use_associated_key?
             ds = ds.eager_graph(opts[:eager_graph])
           end
           ds = ds.eager(associations) unless Array(associations).empty?
-          ds = opts[:eager_block].call(ds) if opts[:eager_block]
           ds = eager_options[:eager_block].call(ds) if eager_options[:eager_block]
           if opts.eager_loading_use_associated_key?
             ds = if opts[:uses_left_composite_keys]
-              t = opts.associated_key_table
-              ds.select_append(*opts.associated_key_alias.zip(opts.associated_key_column).map{|a, c| SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, c), a)})
+              ds.select_append(*opts.associated_key_alias.zip(opts.eager_loading_predicate_key).map{|a, k| SQL::AliasedExpression.new(k, a)})
             else
-              ds.select_append(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column), opts.associated_key_alias))
+              ds.select_append(SQL::AliasedExpression.new(opts.eager_loading_predicate_key, opts.associated_key_alias))
             end
           end
           ds
@@ -963,9 +1044,9 @@ module Sequel
             h = eo[:key_hash][left_pk]
             rows = eo[:rows]
             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)}, h.keys]] : [[left, h.keys]]
-            ds = model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), Array(opts.select), eo[:associations], eo)
+            r = rcks.zip(opts.right_primary_keys)
+            l = [[opts.qualify(opts.join_table_alias, left), h.keys]]
+            ds = model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), nil, eo[:associations], eo)
             case opts.eager_limit_strategy
             when :window_function
               delete_rn = true
@@ -974,7 +1055,7 @@ module Sequel
             when :correlated_subquery
               ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
                 dsa = ds.send(:dataset_alias, 2)
-                xds.inner_join(join_table, r + lcks.map{|k| [k, SQL::QualifiedIdentifier.new(join_table, k)]}, :table_alias=>dsa)
+                xds.inner_join(join_table, r + lcks.map{|k| [k, SQL::QualifiedIdentifier.new(opts.join_table_alias, k)]}, :table_alias=>dsa)
               end
             end
             ds.all do |assoc_record|
@@ -1005,7 +1086,7 @@ module Sequel
           jt_graph_block = opts[:graph_join_table_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table), :join_type=>jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
+            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :join_type=>jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
             ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>eo[:table_alias], :join_type=>join_type, &graph_block)
           end
       
@@ -1037,15 +1118,17 @@ module Sequel
           opts[:key] = opts.default_key unless opts.include?(:key)
           key = opts[:key]
           cks = opts[:keys] = Array(opts[:key])
+          opts[:qualified_key] = opts.qualify_cur(key)
           if opts[:primary_key]
             cpks = Array(opts[:primary_key])
             raise(Error, "mismatched number of composite keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
           end
           uses_cks = opts[:uses_composite_keys] = cks.length > 1
+          qualify = opts[:qualify] != false
           opts[:cartesian_product_number] ||= 0
           opts[:dataset] ||= proc do
             klass = opts.associated_class
-            klass.filter(opts.primary_keys.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}.zip(cks.map{|k| send(k)}))
+            klass.filter(Array(opts.qualified_primary_key).zip(cks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:key_hash][key]
@@ -1056,7 +1139,7 @@ module Sequel
             # 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)}=>keys} : {SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>keys}), opts.select, eo[:associations], eo).all do |assoc_record|
+              model.eager_loading_dataset(opts, klass.filter(opts.qualified_primary_key=>keys), nil, 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}
@@ -1095,8 +1178,7 @@ module Sequel
           raise(Error, "mismatched number of composite keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
           uses_cks = opts[:uses_composite_keys] = cks.length > 1
           opts[:dataset] ||= proc do
-            klass = opts.associated_class
-            klass.filter(cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}.zip(cpks.map{|k| send(k)}))
+            opts.associated_class.filter(Array(opts.qualified_key).zip(cpks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:key_hash][primary_key]
@@ -1109,7 +1191,7 @@ module Sequel
             reciprocal = opts.reciprocal
             klass = opts.associated_class
             filter_keys = opts.eager_loading_predicate_key
-            ds = model.eager_loading_dataset(opts, klass.filter(filter_keys=>h.keys), opts.select, eo[:associations], eo)
+            ds = model.eager_loading_dataset(opts, klass.filter(filter_keys=>h.keys), nil, eo[:associations], eo)
             case opts.eager_limit_strategy
             when :distinct_on
               ds = ds.distinct(*filter_keys).order_prepend(*filter_keys)
@@ -1277,7 +1359,7 @@ module Sequel
 
         # 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])
+          ds = model.db.from(opts.join_table_source)
           opts[:join_table_block] ? opts[:join_table_block].call(ds) : ds
         end
 
@@ -1845,7 +1927,7 @@ module Sequel
           if exp == SQL::Constants::FALSE
             association_filter_handle_inversion(op, exp, Array(lpks))
           else
-            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>model.db[ref[:join_table]].select(*lks).where(exp).exclude(SQL::BooleanExpression.from_value_pairs(lks.zip([]), :OR))), Array(lpks))
+            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>model.db.from(ref[:join_table]).select(*lks).where(exp).exclude(SQL::BooleanExpression.from_value_pairs(lks.zip([]), :OR))), Array(lpks))
           end
         end
 

data/lib/sequel/model/base.rb

@@ -105,6 +105,17 @@ module Sequel
         args = args.first if (args.size == 1)
         args.is_a?(Hash) ? dataset[args] : primary_key_lookup(args)
       end
+
+      # Initializes a model instance as an existing record. This constructor is
+      # used by Sequel to initialize model instances when fetching records.
+      # Requires that values be a hash where all keys are symbols. It
+      # probably should not be used by external code.
+      def call(values)
+        o = allocate
+        o.set_values(values)
+        o.after_initialize
+        o
+      end
       
       # Clear the setter_methods cache
       def clear_setter_methods_cache
@@ -149,9 +160,13 @@ module Sequel
         set_dataset(ds)
       end
 
-      # Extend the dataset with an anonymous module, similar to adding
+      # Extend the dataset with a module, similar to adding
       # a plugin with the methods defined in DatasetMethods.  If a block
-      # is given, it is module_evaled.
+      # is given, an anonymous module is created and the module_evaled, otherwise
+      # the argument should be a module.  Returns the module given or the anonymous
+      # module created.
+      #
+      #   Artist.dataset_module Sequel::ColumnsIntrospection
       #
       #   Artist.dataset_module do
       #     def foo
@@ -162,11 +177,17 @@ module Sequel
       #   # => :bar
       #   Artist.foo
       #   # => :bar
-      def dataset_module
-        @dataset_module ||= Module.new
-        @dataset_module.module_eval(&Proc.new) if block_given?
-        dataset_extend(@dataset_module)
-        @dataset_module
+      def dataset_module(mod = nil)
+        if mod
+          raise Error, "can't provide both argument and block to Model.dataset_module" if block_given?
+          dataset_extend(mod)
+          mod
+        else
+          @dataset_module ||= Module.new
+          @dataset_module.module_eval(&Proc.new) if block_given?
+          dataset_extend(@dataset_module)
+          @dataset_module
+        end
       end
     
       # Returns the database associated with the Model class.
@@ -237,9 +258,30 @@ module Sequel
           @dataset_methods[meth] = block
           dataset.meta_def(meth, &block) if @dataset
         end
-        args.each{|arg| instance_eval("def #{arg}(*args, &block); dataset.#{arg}(*args, &block) end", __FILE__, __LINE__) unless respond_to?(arg)}
+        args.each do |arg|
+          if arg.to_s =~ NORMAL_METHOD_NAME_REGEXP
+            instance_eval("def #{arg}(*args, &block); dataset.#{arg}(*args, &block) end", __FILE__, __LINE__) unless respond_to?(arg, true)
+          else
+            def_model_dataset_method_block(arg)
+          end
+        end
       end
-      
+
+      module_eval(if RUBY_VERSION < '1.8.7'
+        <<-END
+          def def_model_dataset_method_block(arg)
+            meta_def(arg){|*args| dataset.send(arg, *args)}
+          end
+        END
+      else
+        <<-END
+          def def_model_dataset_method_block(arg)
+            meta_def(arg){|*args, &block| dataset.send(arg, *args, &block)}
+          end
+        END
+      end, __FILE__, __LINE__ - 4)
+      private :def_model_dataset_method_block
+
       # Finds a single record according to the supplied filter.
       # You are encouraged to use Model.[] or Model.first instead of this method.
       #
@@ -318,12 +360,9 @@ module Sequel
         pluralize(underscore(demodulize(name))).to_sym
       end
   
-      # Initializes a model instance as an existing record. This constructor is
-      # used by Sequel to initialize model instances when fetching records.
-      # +load+ requires that values be a hash where all keys are symbols. It
-      # probably should not be used by external code.
+      # Calls #call with the values hash.  Only for backwards compatibility.
       def load(values)
-        new(values, true)
+        call(values)
       end
 
       # Clear the setter_methods cache when a setter method is added
@@ -447,13 +486,17 @@ module Sequel
           @simple_table = db.literal(ds)
           db.from(ds)
         when Dataset
-          @simple_table = nil
+          @simple_table = if ds.send(:simple_select_all?)
+            ds.literal(ds.first_source_table)
+          else
+            nil
+          end
           @db = ds.db
           ds
         else
           raise(Error, "Model.set_dataset takes one of the following classes as an argument: Symbol, LiteralString, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, Dataset")
         end
-        @dataset.row_proc = Proc.new{|r| load(r)}
+        @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
@@ -466,7 +509,7 @@ module Sequel
         check_non_connection_error{@db_schema = (inherited ? superclass.db_schema : get_db_schema)}
         self
       end
-    
+
       # Sets the primary key for this model. You can use either a regular 
       # or a composite primary key.  To not use a primary key, set to nil
       # or use +no_primary_key+.  On most adapters, Sequel can automatically
@@ -484,7 +527,11 @@ module Sequel
       def set_primary_key(*key)
         clear_setter_methods_cache
         key = key.flatten
-        @simple_pk = key.length == 1 ? db.literal(key.first) : nil 
+        @simple_pk = if key.length == 1
+          (@dataset || db).literal(key.first)
+        else 
+          nil 
+        end
         @primary_key = (key.length == 1) ? key[0] : key
       end
   
@@ -617,10 +664,9 @@ module Sequel
         return nil unless @dataset
         schema_hash = {}
         ds_opts = dataset.opts
-        single_table = ds_opts[:from] && (ds_opts[:from].length == 1) \
-          && !ds_opts.include?(:join) && !ds_opts.include?(:sql)
         get_columns = proc{check_non_connection_error{columns} || []}
-        if single_table && (schema_array = (db.schema(dataset.first_source_table, :reload=>reload) rescue nil))
+        schema_array = check_non_connection_error{db.schema(dataset, :reload=>reload)}
+        if schema_array
           schema_array.each{|k,v| schema_hash[k] = v}
           if ds_opts.include?(:select)
             # We don't remove the columns from the schema_hash,
@@ -628,6 +674,7 @@ module Sequel
             # even if they are not selected.
             cols = get_columns.call
             cols.each{|c| schema_hash[c] ||= {}}
+            def_column_accessor(*schema_hash.keys)
           else
             # Dataset is for a single table with all columns,
             # so set the columns based on the order they were
@@ -741,7 +788,7 @@ module Sequel
     # * The following instance_methods all call the class method of the same
     #   name: columns, db, primary_key, db_schema.
     # * All of the methods in +BOOLEAN_SETTINGS+ create attr_writers allowing you
-    #   to set values for the attribute.  It also creates instnace getters returning
+    #   to set values for the attribute.  It also creates instance getters returning
     #   the value of the setting.  If the value has not yet been set, it
     #   gets the default value from the class by calling the class method of the same name.
     module InstanceMethods
@@ -784,7 +831,7 @@ module Sequel
       #
       # Arguments:
       # values :: should be a hash to pass to set. 
-      # from_db :: should only be set by <tt>Model.load</tt>, forget it exists.
+      # from_db :: only for backwards compatibility, forget it exists.
       #
       #   Artist.new(:name=>'Bob')
       #
@@ -793,7 +840,6 @@ module Sequel
       #   end
       def initialize(values = {}, from_db = false)
         if from_db
-          @new = false
           set_values(values)
         else
           @values = {}
@@ -1034,7 +1080,7 @@ module Sequel
       #   Artist.new.new? # => true
       #   Artist[1].new? # => false
       def new?
-        @new
+        defined?(@new) ? @new : (@new = false)
       end
       
       # Returns the primary key value identifying the model instance.
@@ -1179,6 +1225,13 @@ module Sequel
         set_restricted(hash, only.flatten, false)
       end
   
+      # Replace the current values with hash.  Should definitely not be
+      # used with untrusted input, and should probably not be called
+      # directly by user code.
+      def set_values(hash)
+        @values = hash
+      end
+      
       # Clear the setter_methods cache when a method is added
       def singleton_method_added(meth)
         @singleton_setter_added = true if meth.to_s =~ SETTER_METHOD_REGEXP
@@ -1286,6 +1339,8 @@ module Sequel
       # 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}
         called = false
         around_destroy do
           called = true
@@ -1295,6 +1350,7 @@ module Sequel
           true
         end
         raise_hook_failure(:destroy) unless called
+        db.after_commit(sh){after_destroy_commit}
         self
       end
       
@@ -1355,6 +1411,8 @@ module Sequel
       # Internal version of save, split from save to allow running inside
       # it's own transaction.
       def _save(columns, opts)
+        sh = {:server=>this_server}
+        db.after_rollback(sh){after_rollback}
         was_new = false
         pk = nil
         called_save = false
@@ -1408,6 +1466,7 @@ module Sequel
           @columns_updated = nil
         end
         @modified = false
+        db.after_commit(sh){after_commit}
         self
       end
 
@@ -1506,7 +1565,7 @@ module Sequel
       
       # If transactions should be used, wrap the yield in a transaction block.
       def checked_transaction(opts={})
-        use_transaction?(opts) ? db.transaction(opts){yield} : yield
+        use_transaction?(opts) ? db.transaction({:server=>this_server}.merge(opts)){yield} : yield
       end
 
       # Set the columns with the given hash.  By default, the same as +set+, but
@@ -1563,11 +1622,6 @@ module Sequel
         self
       end
       
-      # Replace the current values with hash.
-      def set_values(hash)
-        @values = hash
-      end
-      
       # Returns all methods that can be used for attribute
       # assignment (those that end with =), modified by the only
       # and except arguments:
@@ -1596,6 +1650,12 @@ module Sequel
           meths
         end
       end
+
+      # 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)
+      end
   
       # Typecast the value to the column's type if typecasting.  Calls the database's
       # typecast_value method, so database adapters can override/augment the handling