sequel 3.4.0 → 3.5.0

data/lib/sequel/model/base.rb

@@ -317,8 +317,9 @@ module Sequel
       # You can set it to nil to not have a primary key, but that
       # cause certain things not to work, see no_primary_key.
       def set_primary_key(*key)
+        key = key.flatten
         @simple_pk = key.length == 1 ? db.literal(key.first) : nil 
-        @primary_key = (key.length == 1) ? key[0] : key.flatten
+        @primary_key = (key.length == 1) ? key[0] : key
       end
   
       # Set the columns to restrict in new/set/update.  Using this means that
@@ -489,7 +490,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")}
+        meths.each{|meth| class_eval("def #{meth}; !defined?(@#{meth}) ? (@#{meth} = self.class.#{meth}) : @#{meth} end", __FILE__, __LINE__)}
         attr_writer(*meths) 
       end 
     
@@ -498,7 +499,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")}
+        meths.each{|meth| class_eval("def #{meth}; model.#{meth} end", __FILE__, __LINE__)}
       end
 
       private_class_method :class_attr_overridable, :class_attr_reader
@@ -539,21 +540,19 @@ module Sequel
         @values[column]
       end
   
-      # Sets value of the column's attribute and marks the column as changed.
-      # If the column already has the same value, this is a no-op. Note that
-      # changing a columns value and then changing it back will cause the
-      # column to appear in changed_columns.  Similarly, providing a
-      # value that is different from the column's current value but is the
-      # same after typecasting will also cause changed_columns to include the
-      # column.
+      # Sets the value for the given column.  If typecasting is enabled for
+      # this object, typecast the value based on the column's type.
+      # If this a a new record or the typecasted value isn't the same
+      # as the current value for the column, mark the column as changed.
       def []=(column, value)
         # If it is new, it doesn't have a value yet, so we should
         # definitely set the new value.
         # If the column isn't in @values, we can't assume it is
         # NULL in the database, so assume it has changed.
-        if new? || !@values.include?(column) || value != @values[column]
+        v = typecast_value(column, value)
+        if new? || !@values.include?(column) || v != @values[column]
           changed_columns << column unless changed_columns.include?(column)
-          @values[column] = typecast_value(column, value)
+          @values[column] = v
         end
       end
   
@@ -655,9 +654,10 @@ module Sequel
       end
       
       # Whether this object has been modified since last saved, used by
-      # save_changes to determine whether changes should be saved
+      # save_changes to determine whether changes should be saved.  New
+      # values are always considered modified.
       def modified?
-        !changed_columns.empty?
+        new? || !changed_columns.empty?
       end
   
       # Returns true if the current instance represents a new record.
@@ -802,6 +802,22 @@ module Sequel
         self
       end
       
+      def _insert
+        ds = model.dataset
+        if ds.respond_to?(:insert_select) and h = ds.insert_select(@values)
+          @values = h
+          nil
+        else
+          iid = ds.insert(@values)
+          # 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
+          end
+          pk
+        end
+      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)
@@ -817,19 +833,8 @@ module Sequel
         return save_failure(:save) if before_save == false
         if new?
           return save_failure(:create) if before_create == false
-          ds = model.dataset
-          if ds.respond_to?(:insert_select) and h = ds.insert_select(@values)
-            @values = h
-            @this = nil
-          else
-            iid = ds.insert(@values)
-            # 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
-            end
-            @this = nil if pk
-          end
+          pk = _insert
+          @this = nil if pk
           @new = false
           @was_new = true
           after_create
@@ -850,7 +855,7 @@ module Sequel
             changed_columns.reject!{|c| columns.include?(c)}
           end
           Array(primary_key).each{|x| @columns_updated.delete(x)}
-          this.update(@columns_updated) unless @columns_updated.empty?
+          _update(@columns_updated) unless @columns_updated.empty?
           after_update
           after_save
           @columns_updated = nil
@@ -858,6 +863,10 @@ module Sequel
         self
       end
       
+      def _update(columns)
+        this.update(columns)
+      end
+      
       # Default inspection output for the values hash, overwrite to change what #inspect displays.
       def inspect_values
         @values.inspect

data/lib/sequel/plugins/active_model.rb

@@ -0,0 +1,35 @@
+module Sequel
+  module Plugins
+    # The ActiveModel plugin makes Sequel::Model objects the
+    # pass the ActiveModel::Lint tests, which should
+    # hopefully mean full ActiveModel compliance.  This should
+    # allow the full support of Sequel::Model objects in Rails 3.
+    module ActiveModel
+      module InstanceMethods
+        # Record that an object was destroyed, for later use by
+        # destroyed?
+        def after_destroy
+          super
+          @destroyed = true
+        end
+        
+        # Whether the object was destroyed by destroy.  Not true
+        # for objects that were deleted.
+        def destroyed?
+          @destroyed == true
+        end
+        
+        # An alias for new?
+        def new_record?
+          new?
+        end
+
+        # With the ActiveModel plugin, Sequel model objects are already
+        # compliant, so this returns self.
+        def to_model
+          self
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/association_dependencies.rb

@@ -0,0 +1,96 @@
+module Sequel
+  module Plugins
+    # The AssociationDependencies plugin allows you do easily set up before and/or after destroy hooks
+    # for destroying, deleting, or nullifying associated model objects.  The following
+    # association types support the following dependency actions:
+    # 
+    # * :many_to_many - :nullify (removes all related entries in join table)
+    # * :many_to_one - :delete, :destroy
+    # * :one_to_many - :delete, :destroy, :nullify (sets foreign key to NULL for all associated objects)
+    #
+    # This plugin works directly with the association datasets and does not use any cached association values.
+    # The :delete action will delete all associated objects from the database in a single SQL call.
+    # The :destroy action will load each associated object from the database and call the destroy method on it.
+    #
+    # To set up an association dependency, you must provide a hash with association name symbols
+    # and dependency action values.  You can provide the hash to the plugin call itself or
+    # to the add_association_dependencies method:
+    #
+    #   Business.plugin :association_dependencies, :address=>delete
+    #   # or:
+    #   Artist.plugin :association_dependencies
+    #   Artist.add_association_dependencies :albums=>:destroy, :reviews=>:delete, :tags=>:nullify
+    module AssociationDependencies
+      # Mapping of association types to when the dependency calls should be made (either
+      # :before for in before_destroy or :after for in after_destroy)
+      ASSOCIATION_MAPPING = {:one_to_many=>:before, :many_to_one=>:after, :many_to_many=>:before}
+
+      # The valid dependence actions
+      DEPENDENCE_ACTIONS = [:delete, :destroy, :nullify]
+
+      # Initialize the association_dependencies hash for this model.
+      def self.apply(model, hash={})
+        model.instance_eval{@association_dependencies = {:before_delete=>[], :before_destroy=>[], :before_nullify=>[], :after_delete=>[], :after_destroy=>[]}}
+      end
+
+      # Call add_association_dependencies with any dependencies given in the plugin call.
+      def self.configure(model, hash={})
+        model.add_association_dependencies(hash) unless hash.empty?
+      end
+
+      module ClassMethods
+        # A hash specifying the association dependencies for each model.  The keys
+        # are symbols indicating the type of action and when it should be executed
+        # (e.g. :before_delete).  Values are an array of method symbols.
+        # For before_nullify, the symbols are remove_all_association methods.  For other
+        # types, the symbols are association_dataset methods, on which delete or
+        # destroy is called.
+        attr_reader :association_dependencies
+
+        # Add association dependencies to this model.  The hash should have association name
+        # symbol keys and dependency action symbol values (e.g. :albums=>:destroy).
+        def add_association_dependencies(hash)
+          hash.each do |association, action|
+            raise(Error, "Nonexistent association: #{association}") unless r = association_reflection(association)
+            raise(Error, "Invalid dependence action type: association: #{association}, dependence action: #{action}") unless DEPENDENCE_ACTIONS.include?(action)
+            raise(Error, "Invalid association type: association: #{association}, type: #{r[:type]}") unless time = ASSOCIATION_MAPPING[r[:type]]
+            association_dependencies[:"#{time}_#{action}"] << if action == :nullify
+              raise(Error, "Can't nullify many_to_one associated objects: association: #{association}") if r[:type] == :many_to_one
+              r.remove_all_method
+            else
+              raise(Error, "Can only nullify many_to_many associations: association: #{association}") if r[:type] == :many_to_many
+              r.dataset_method
+            end
+          end
+        end
+
+        # Copy the current model object's association_dependencies into the subclass.
+        def inherited(subclass)
+          super
+          ad = association_dependencies.dup
+          ad.keys.each{|k| ad[k] = ad[k].dup}
+          subclass.instance_variable_set(:@association_dependencies, ad)
+        end
+      end
+
+      module InstanceMethods
+        # Run the delete and destroy association dependency actions for
+        # many_to_one associations.
+        def after_destroy
+          super
+          model.association_dependencies[:after_delete].each{|m| send(m).delete}
+          model.association_dependencies[:after_destroy].each{|m| send(m).destroy}
+        end
+
+        # Run the delete, destroy, and nullify association dependency actions for
+        # *_to_many associations.
+        def before_destroy
+          model.association_dependencies[:before_delete].each{|m| send(m).delete}
+          model.association_dependencies[:before_destroy].each{|m| send(m).destroy}
+          model.association_dependencies[:before_nullify].each{|m| send(m)}
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -0,0 +1,214 @@
+module Sequel
+  module Plugins
+    # The class_table_inheritance plugin allows you to model inheritance in the
+    # database using a table per model class in the hierarchy, with only columns
+    # unique to that model class (or subclass hierarchy) being stored in the related
+    # table.  For example, with this hierarchy:
+    #
+    #                        Employee
+    #                       /        \ 
+    #                    Staff     Manager
+    #                                 |
+    #                             Executive
+    #
+    # the following database schema may be used (table - columns):
+    #
+    # * employees - id, name, kind
+    # * staff - id, manager_id
+    # * managers - id, num_staff
+    # * executives - id, num_managers
+    #
+    # The class_table_inheritance plugin assumes that the main table
+    # (e.g. employees) has a primary key field (usually autoincrementing),
+    # and all other tables have a foreign key of the same name that points
+    # to the same key in their superclass's table.  For example:
+    #
+    # * employees.id  - primary key, autoincrementing
+    # * staff.id - foreign key referencing employees(id)
+    # * managers.id - foreign key referencing employees(id)
+    # * executives.id - foreign key referencing managers(id)
+    #
+    # When using the class_table_inheritance plugin, subclasses use joined 
+    # datasets:
+    #
+    #   Employee.dataset.sql  # SELECT * FROM employees
+    #   Manager.dataset.sql   # SELECT * FROM employees
+    #                         # INNER JOIN managers USING (id)
+    #   Executive.dataset.sql # SELECT * FROM employees 
+    #                         # INNER JOIN managers USING (id)
+    #                         # INNER JOIN executives USING (id)
+    #
+    # This allows Executive.all to return instances with all attributes
+    # loaded.  The plugin overrides the deleting, inserting, and updating
+    # in the model to work with multiple tables, by handling each table
+    # individually.
+    #
+    # This plugin allows the use of a :key option when loading to mark
+    # a column holding a class name.  This allows methods on the
+    # superclass to return instances of specific subclasses.
+    # This plugin also requires the lazy_attributes plugin and uses it to
+    # return subclass specific attributes that would not be loaded
+    # when calling superclass methods (since those wouldn't join
+    # to the subclass tables).  For example:
+    #
+    #   a = Employee.all # [<#Staff>, <#Manager>, <#Executive>]
+    #   a.first.values # {:id=>1, name=>'S', :kind=>'Staff'}
+    #   a.first.manager_id # Loads the manager_id attribute from the database
+    module ClassTableInheritance
+      # The class_table_inheritance plugin requires the lazy_attributes plugin
+      # to handle lazily-loaded attributes for subclass instances returned
+      # by superclass methods.
+      def self.apply(model, opts={}, &block)
+        model.plugin :lazy_attributes
+      end
+      
+      # Initialize the per-model data structures and set the dataset's row_proc
+      # to check for the :key option column for the type of class when loading objects.
+      # Options:
+      # * :key - The column symbol holding the name of the model class this
+      #   is an instance of.  Necessary if you want to call model methods
+      #   using the superclass, but have them return subclass instances.
+      # * :table_map - Hash with class name symbol keys and table name symbol
+      #   values.  Necessary if the implicit table name for the model class
+      #   does not match the database table name
+      # Example:
+      #   class Employee < Sequel::Model
+      #     plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
+      #   end
+      def self.configure(model, opts={}, &block)
+        model.instance_eval do
+          m = method(:constantize)
+          @cti_base_model = self
+          @cti_key = key = opts[:key] 
+          @cti_tables = [table_name]
+          @cti_columns = {table_name=>columns}
+          @cti_table_map = opts[:table_map] || {}
+          dataset.row_proc = lambda{|r| (m.call(r[key]) rescue model).load(r)}
+        end
+      end
+
+      module ClassMethods
+        # The parent/root/base model for this class table inheritance hierarchy.
+        # This is the only model in the hierarchy that load the
+        # class_table_inheritance plugin.
+        attr_reader :cti_base_model
+        
+        # Hash with table name symbol keys and arrays of column symbol values,
+        # giving the columns to update in each backing database table.
+        attr_reader :cti_columns
+        
+        # The column containing the class name as a string.  Used to
+        # return instances of subclasses when calling the superclass's
+        # load method.
+        attr_reader :cti_key
+        
+        # An array of table symbols that back this model.  The first is
+        # cti_base_model table symbol, and the last is the current model
+        # table symbol.
+        attr_reader :cti_tables
+        
+        # A hash with class name symbol keys and table name symbol values.
+        # Specified with the :table_map option to the plugin, and used if
+        # the implicit naming is incorrect.
+        attr_reader :cti_table_map
+        
+        # Add the appropriate data structures to the subclass.  Does not
+        # allow anonymous subclasses to be created, since they would not
+        # be mappable to a table.
+        def inherited(subclass)
+          cc = cti_columns
+          ck = cti_key
+          ct = cti_tables.dup
+          ctm = cti_table_map.dup
+          cbm = cti_base_model
+          pk = primary_key
+          ds = dataset
+          subclass.instance_eval do
+            raise(Error, "cannot create anonymous subclass for model class using class_table_inheritance") if !(n = name) || n.empty?
+            table = ctm[n.to_sym] || implicit_table_name
+            columns = db.from(table).columns
+            @cti_key = ck 
+            @cti_tables = ct + [table]
+            @cti_columns = cc.merge(table=>columns)
+            @cti_table_map = ctm
+            @cti_base_model = cbm
+            # Need to set dataset and columns before calling super so that
+            # the main column accessor module is included in the class before any
+            # plugin accessor modules (such as the lazy attributes accessor module).
+            set_dataset(ds.join(table, [pk]))
+            set_columns(self.columns)
+          end
+          super
+          subclass.instance_eval do
+            m = method(:constantize)
+            dataset.row_proc = lambda{|r| (m.call(r[ck]) rescue subclass).load(r)}
+            (columns - [cbm.primary_key]).each{|a| define_lazy_attribute_getter(a)}
+            cti_tables.reverse.each do |table|
+              db.schema(table).each{|k,v| db_schema[k] = v}
+            end
+          end
+        end
+        
+        # The primary key in the parent/base/root model, which should have a
+        # foreign key with the same name referencing it in each model subclass.
+        def primary_key
+          return super if self == cti_base_model
+          cti_base_model.primary_key
+        end
+        
+        # The table name for the current model class's main table (not used
+        # by any superclasses).
+        def table_name
+          self == cti_base_model ? super : cti_tables.last
+        end
+      end
+
+      module InstanceMethods
+        # Set the cti_key column to the name of the model.
+        def before_create
+          return false if super == false
+          send("#{model.cti_key}=", model.name.to_s) if model.cti_key
+        end
+        
+        # Delete the row from all backing tables, starting from the
+        # most recent table and going through all superclasses.
+        def delete
+          m = model
+          m.cti_tables.reverse.each do |table|
+            m.db.from(table).filter(m.primary_key=>pk).delete
+          end
+          self
+        end
+        
+        private
+        
+        # Insert rows into all backing tables, using the columns
+        # in each table.  
+        def _insert
+          return super if model == model.cti_base_model
+          iid = nil
+          m = model
+          m.cti_tables.each do |table|
+            h = {}
+            h[m.primary_key] = iid if iid
+            m.cti_columns[table].each{|c| h[c] = @values[c] if @values.include?(c)}
+            nid = m.db.from(table).insert(h)
+            iid ||= nid
+          end
+          @values[primary_key] = iid
+        end
+        
+        # Update rows in all backing tables, using the columns in each table.
+        def _update(columns)
+          pkh = pk_hash
+          m = model
+          m.cti_tables.each do |table|
+            h = {}
+            m.cti_columns[table].each{|c| h[c] = columns[c] if columns.include?(c)}
+            m.db.from(table).filter(pkh).update(h) unless h.empty?
+          end
+        end
+      end
+    end
+  end
+end