sequel 3.5.0 → 3.6.0

data/lib/sequel/model/associations.rb

@@ -56,7 +56,13 @@ module Sequel
         def associated_class
           self[:class] ||= constantize(self[:class_name])
         end
-      
+        
+        # Whether this association can have associated objects, given the current
+        # object.  Should be false if obj cannot have associated objects because
+        # the necessary key columns are NULL.
+        def can_have_associated_objects?(obj)
+          true
+        end
 
         # Name symbol for the dataset association method
         def dataset_method
@@ -126,6 +132,11 @@ module Sequel
           :"remove_#{singularize(self[:name])}"
         end
       
+        # Whether to check that an object to be disassociated is already associated to this object, false by default.
+        def remove_should_check_existing?
+          false
+        end
+
         # Whether this association returns an array of objects instead of a single object,
         # true by default.
         def returns_array?
@@ -152,6 +163,12 @@ module Sequel
       class ManyToOneAssociationReflection < AssociationReflection
         ASSOCIATION_TYPES[:many_to_one] = self
     
+        # many_to_one associations can only have associated objects if none of
+        # the :keys options have a nil value.
+        def can_have_associated_objects?(obj)
+          !self[:keys].any?{|k| obj.send(k).nil?}
+        end
+        
         # Whether the dataset needs a primary key to function, false for many_to_one associations.
         def dataset_need_primary_key?
           false
@@ -183,6 +200,7 @@ module Sequel
         def primary_keys
          self[:primary_keys] ||= Array(primary_key)
         end
+        alias associated_object_keys primary_keys
       
         # Whether this association returns an array of objects instead of a single object,
         # false for a many_to_one association.
@@ -200,6 +218,17 @@ module Sequel
     
       class OneToManyAssociationReflection < AssociationReflection
         ASSOCIATION_TYPES[:one_to_many] = self
+        
+        # The keys in the associated model's table related to this association
+        def associated_object_keys
+          self[:keys]
+        end
+
+        # one_to_many associations can only have associated objects if none of
+        # the :keys options have a nil value.
+        def can_have_associated_objects?(obj)
+          !self[:primary_keys].any?{|k| obj.send(k).nil?}
+        end
     
         # Default foreign key name symbol for key in associated table that points to
         # current table's primary key.
@@ -224,6 +253,11 @@ module Sequel
           false
         end
     
+        # The one_to_many association needs to check that an object to be removed already is associated.
+        def remove_should_check_existing?
+          true
+        end
+
         private
     
         # The reciprocal type of a one_to_many association is a many_to_one association.
@@ -249,6 +283,12 @@ module Sequel
         def associated_key_table
           self[:join_table]
         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)
+          !self[:left_primary_keys].any?{|k| obj.send(k).nil?}
+        end
 
         # The default associated key alias(es) to use when eager loading
         # associations via eager.
@@ -314,6 +354,7 @@ 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
@@ -432,6 +473,8 @@ module Sequel
         #   - :conditions - The conditions to use to filter the association, can be any argument passed to filter.
         #   - :dataset - A proc that is instance_evaled to get the base dataset
         #     to use for the _dataset method (before the other options are applied).
+        #   - :distinct - Use the DISTINCT clause when selecting associating object, both when
+        #     lazy loading and eager loading via .eager (but not when using .eager_graph).
         #   - :eager - The associations to eagerly load via #eager when loading the associated object(s).
         #     For many_to_one associations, this is ignored unless this association is
         #     being eagerly loaded, as it doesn't save queries unless multiple objects
@@ -597,6 +640,7 @@ module Sequel
           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]
             ds = ds.eager_graph(opts[:eager_graph])
             ds = ds.add_graph_aliases(opts.associated_key_alias=>[opts.associated_class.table_name, opts.associated_key_alias, SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column)]) if opts.eager_loading_use_associated_key?
@@ -903,7 +947,7 @@ module Sequel
 
         # Backbone behind association dataset methods
         def _dataset(opts)
-          raise(Sequel::Error, "model object #{model} does not have a primary key") if opts.dataset_need_primary_key? && !pk
+          raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
           ds = send(opts._dataset_method)
           ds.extend(AssociationDatasetMethods)
           ds.model_object = self
@@ -916,6 +960,7 @@ module Sequel
           ds = ds.order(*opts[:order]) if opts[:order]
           ds = ds.limit(*opts[:limit]) if opts[:limit]
           ds = ds.eager(*opts[:eager]) if opts[:eager]
+          ds = ds.distinct if opts[:distinct]
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
           ds = send(opts.dataset_helper_method, ds) if opts[:block]
           ds
@@ -924,11 +969,11 @@ module Sequel
         # Return the associated objects from the dataset, without callbacks, reciprocals, and caching.
         def _load_associated_objects(opts)
           if opts.returns_array?
-            send(opts.dataset_method).all
+            opts.can_have_associated_objects?(self) ? send(opts.dataset_method).all : []
           else
             if !opts[:key]
               send(opts.dataset_method).all.first
-            elsif opts[:keys].all?{|k| send(k)}
+            elsif opts.can_have_associated_objects?(self)
               send(opts.dataset_method).first
             end
           end
@@ -936,14 +981,22 @@ module Sequel
 
         # Add the given associated object to the given association
         def add_associated_object(opts, o, *args)
-          raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
+          klass = opts.associated_class
+          if o.is_a?(Hash)
+            o = klass.new(o)
+          elsif !o.is_a?(klass)
+            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.model} does not have a primary key") unless o.pk
+            raise(Sequel::Error, "associated object #{o.inspect} does not have a primary key") unless o.pk
           end
           return if run_association_callbacks(opts, :before_add, o) == false
           send(opts._add_method, o, *args)
-          associations[opts[:name]].push(o) if associations.include?(opts[:name])
+          if array = associations[opts[:name]] and !array.include?(o)
+            array.push(o)
+          end
           add_reciprocal_object(opts, o)
           run_association_callbacks(opts, :after_add, o)
           o
@@ -982,7 +1035,7 @@ module Sequel
 
         # Remove all associated objects from the given association
         def remove_all_associated_objects(opts, *args)
-          raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
+          raise(Sequel::Error, "model object #{inspect} does not have a primary key") unless pk
           send(opts._remove_all_method, *args)
           ret = associations[opts[:name]].each{|o| remove_reciprocal_object(opts, o)} if associations.include?(opts[:name])
           associations[opts[:name]] = []
@@ -991,8 +1044,18 @@ module Sequel
 
         # Remove the given associated object from the given association
         def remove_associated_object(opts, o, *args)
-          raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
-          raise(Sequel::Error, "associated object #{o.model} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
+          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)
+          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?
+            raise(Sequel::Error, "associated object #{o.inspect} is not currently associated to #{inspect}")
+          end
+          raise(Sequel::Error, "model object #{inspect} does not have a primary key") unless pk
+          raise(Sequel::Error, "associated object #{o.inspect} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
           return if run_association_callbacks(opts, :before_remove, o) == false
           send(opts._remove_method, o, *args)
           associations[opts[:name]].delete_if{|x| o === x} if associations.include?(opts[:name])
@@ -1027,7 +1090,7 @@ module Sequel
               raise Error, "callbacks should either be Procs or Symbols"
             end
             if res == false and stop_on_false
-              raise(BeforeHookFailed, "Unable to modify association for record: one of the #{callback_type} hooks returned false") if raise_error
+              raise(BeforeHookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false") if raise_error
               return false
             end
           end
@@ -1035,7 +1098,7 @@ module Sequel
 
         # Set the given object as the associated object for the given association
         def set_associated_object(opts, o)
-          raise(Sequel::Error, "model object #{model} does not have a primary key") if o && !o.pk
+          raise(Sequel::Error, "associated object #{o.inspect} does not have a primary key") if o && !o.pk
           old_val = send(opts.association_method)
           return o if old_val == o
           return if old_val and run_association_callbacks(opts, :before_remove, old_val) == false
@@ -1151,6 +1214,7 @@ module Sequel
         # call each, you will get a normal graphed result back (a hash with model object values).
         def eager_graph(*associations)
           table_name = model.table_name
+            
           ds = if @opts[:eager_graph]
             self
           else
@@ -1159,7 +1223,7 @@ module Sequel
             # :requirements - array of requirements for this association
             # :alias_association_type_map - the type of association for this association
             # :alias_association_name_map - the name of the association for this association
-            clone(:eager_graph=>{:requirements=>{}, :master=>model.table_name, :alias_association_type_map=>{}, :alias_association_name_map=>{}, :reciprocals=>{}, :cartesian_product_number=>0})
+            clone(:eager_graph=>{:requirements=>{}, :master=>table_name, :alias_association_type_map=>{}, :alias_association_name_map=>{}, :reciprocals=>{}, :cartesian_product_number=>0})
           end
           ds.eager_graph_associations(ds, model, table_name, [], *associations)
         end

data/lib/sequel/model/base.rb

@@ -173,6 +173,7 @@ module Sequel
       # is created.  Also, make sure the inherited class instance variables
       # are copied into the subclass.
       def inherited(subclass)
+        super
         ivs = subclass.instance_variables.collect{|x| x.to_s}
         EMPTY_INSTANCE_VARIABLES.each{|iv| subclass.instance_variable_set(iv, nil) unless ivs.include?(iv.to_s)}
         INHERITED_INSTANCE_VARIABLES.each do |iv, dup|
@@ -357,7 +358,7 @@ module Sequel
       
       # Returns name of primary table for the dataset.
       def table_name
-        dataset.opts[:from].first
+        dataset.first_source_alias
       end
   
       # Allow the setting of the primary key(s) inside new/set/update.
@@ -524,10 +525,11 @@ module Sequel
       def initialize(values = {}, from_db = false)
         if from_db
           @new = false
-          @values = values
+          set_values(values)
         else
           @values = {}
           @new = true
+          @modified = true
           set(values)
           changed_columns.clear 
           yield self if block_given?
@@ -653,11 +655,23 @@ module Sequel
         @values.keys
       end
       
+      # Remove elements of the model object that make marshalling fail. Returns self.
+      def marshallable!
+        @this = nil
+        self
+      end
+
+      # Explicitly mark the object as modified, so save_changes/update will
+      # run callbacks even if no columns have changed.
+      def modified!
+        @modified = true
+      end
+
       # Whether this object has been modified since last saved, used by
       # save_changes to determine whether changes should be saved.  New
       # values are always considered modified.
       def modified?
-        new? || !changed_columns.empty?
+        @modified || !changed_columns.empty?
       end
   
       # Returns true if the current instance represents a new record.
@@ -715,8 +729,8 @@ module Sequel
       # Saves only changed columns if the object has been modified.
       # If the object has not been modified, returns nil.  If unable to
       # save, returns false unless raise_on_save_failure is true.
-      def save_changes
-        save(:changed=>true) || false if modified? 
+      def save_changes(opts={})
+        save(opts.merge(:changed=>true)) || false if modified? 
       end
   
       # Updates the instance with the supplied values with support for virtual
@@ -750,7 +764,7 @@ module Sequel
         @this ||= model.dataset.filter(pk_hash).limit(1).naked
       end
       
-      # Runs set with the passed hash and runs save_changes (which runs any callback methods).
+      # Runs set with the passed hash and then runs save_changes.
       def update(hash)
         update_restricted(hash, nil, nil)
       end
@@ -821,7 +835,7 @@ module Sequel
       # 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)
-        @values = dataset.first || raise(Error, "Record not found")
+        set_values(dataset.first || raise(Error, "Record not found"))
         changed_columns.clear
         associations.clear
         self
@@ -844,6 +858,8 @@ module Sequel
             ds = this
             ds = ds.server(:default) unless ds.opts[:server]
             _refresh(ds)
+          else
+            changed_columns.clear
           end
         else
           return save_failure(:update) if before_update == false
@@ -860,6 +876,7 @@ module Sequel
           after_save
           @columns_updated = nil
         end
+        @modified = false
         self
       end
       
@@ -897,7 +914,12 @@ module Sequel
         end
         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:

data/lib/sequel/model/errors.rb

@@ -3,11 +3,11 @@ module Sequel
     # Errors represents validation errors, a simple hash subclass
     # with a few convenience methods.
     class Errors < ::Hash
-      ATTRIBUTE_JOINER = ' and '
+      ATTRIBUTE_JOINER = ' and '.freeze
 
       # Assign an array of messages for each attribute on access
-      def initialize
-        super{|h,k| h[k] = []}
+      def [](k)
+        has_key?(k) ? super : (self[k] = [])
       end
 
       # Adds an error for the given attribute.
@@ -32,7 +32,7 @@ module Sequel
       # Returns the array of errors for the given attribute, or nil
       # if there are no errors for the attribute.
       def on(att)
-        self[att] if include?(att)
+        self[att] if has_key?(att)
       end
     end
   end

data/lib/sequel/plugins/caching.rb

@@ -1,8 +1,8 @@
 module Sequel
   module Plugins
     # Sequel's built-in caching plugin supports caching to any object that
-    # implements the Ruby-Memcache API.  You can add caching for any model
-    # or for all models via:
+    # implements the Ruby-Memcache API (or memcached API with the :ignore_exceptions
+    # option).  You can add caching for any model or for all models via:
     #
     #   Model.plugin :caching, store   # Cache all models
     #   MyModel.plugin :caching, store # Just cache MyModel
@@ -11,10 +11,15 @@ module Sequel
     #
     #    cache_store.set(key, obj, time) # Associate the obj with the given key
     #                                    # in the cache for the time (specified
-    #                                    # in seconds)
-    #    cache_store.get(key) => obj # Returns object set with same key
-    #    cache_store.get(key2) => nil # nil returned if there isn't an object
-    #                                 # currently in the cache with that key
+    #                                    # in seconds).
+    #    cache_store.get(key) => obj     # Returns object set with same key.
+    #    cache_store.get(key2) => nil    # nil returned if there isn't an object
+    #                                    # currently in the cache with that key.
+    #
+    # If the :ignore_exceptions option is true, exceptions raised by cache_store.get
+    # are ignored and nil is returned instead.  The memcached API is to
+    # raise an exception for a missing record, so if you use memcached, you will
+    # want to use this option.
     module Caching
       # Set the cache_store and cache_ttl attributes for the given model.
       # If the :ttl option is not given, 3600 seconds is the default.
@@ -22,12 +27,16 @@ module Sequel
         model.instance_eval do
           @cache_store = store
           @cache_ttl = opts[:ttl] || 3600
+          @cache_ignore_exceptions = opts[:ignore_exceptions]
         end
       end
 
       module ClassMethods
+        # If true, ignores exceptions when gettings cached records (the memcached API).
+        attr_reader :cache_ignore_exceptions
+        
         # The cache store object for the model, which should implement the
-        # Ruby-Memcache API
+        # Ruby-Memcache (or memcached) API
         attr_reader :cache_store
         
         # The time to live for the cache store, in seconds.
@@ -38,38 +47,52 @@ module Sequel
           @cache_ttl = ttl
         end
         
-        # Copy the cache_store and cache_ttl to the subclass.
+        # Copy the necessary class instance variables to the subclass.
         def inherited(subclass)
           super
           store = @cache_store
           ttl = @cache_ttl
+          cache_ignore_exceptions = @cache_ignore_exceptions
           subclass.instance_eval do
             @cache_store = store
             @cache_ttl = ttl
+            @cache_ignore_exceptions = cache_ignore_exceptions
           end
         end
 
         private
     
         # Delete the entry with the matching key from the cache
-        def cache_delete(key)
-          @cache_store.delete(key)
+        def cache_delete(ck)
+          @cache_store.delete(ck)
           nil
         end
+        
+        def cache_get(ck)
+          if @cache_ignore_exceptions
+            @cache_store.get(ck) rescue nil
+          else
+            @cache_store.get(ck)
+          end
+        end
     
         # Return a key string for the pk
         def cache_key(pk)
           "#{self}:#{Array(pk).join(',')}"
         end
         
+        # Set the object in the cache_store with the given key for cache_ttl seconds.
+        def cache_set(ck, obj)
+          @cache_store.set(ck, obj, @cache_ttl)
+        end
+        
         # Check the cache before a database lookup unless a hash is supplied.
         def primary_key_lookup(pk)
           ck = cache_key(pk)
-          if obj = @cache_store.get(ck)
-            return obj
-          end
-          if obj = super(pk)
-            @cache_store.set(ck, obj, @cache_ttl)
+          unless obj = cache_get(ck)
+            if obj = super(pk)
+              cache_set(ck, obj)
+            end
           end 
           obj
         end