sequel 3.11.0 → 3.12.0

data/lib/sequel/plugins/nested_attributes.rb

@@ -7,6 +7,7 @@ module Sequel
     # Nested attributes are created using the nested_attributes method:
     #
     #   Artist.one_to_many :albums
+    #   Artist.plugin :nested_attributes
     #   Artist.nested_attributes :albums
     #   a = Artist.new(:name=>'YJM',
     #    :albums_attributes=>[{:name=>'RF'}, {:name=>'MO'}])

data/lib/sequel/plugins/optimistic_locking.rb

@@ -1,5 +1,5 @@
 module Sequel
-  require 'plugins/instance_filters'
+  tsk_require 'sequel/plugins/instance_filters'
   
   module Plugins
     # This plugin implements a simple database-independent locking mechanism

data/lib/sequel/plugins/rcte_tree.rb

@@ -146,11 +146,11 @@ module Sequel
           end
         end
         a[:after_load] ||= aal
-        a[:eager_loader] ||= proc do |key_hash, objects, associations|
-          id_map = key_hash[key]
+        a[:eager_loader] ||= proc do |eo|
+          id_map = eo[:key_hash][key]
           parent_map = {}
           children_map = {}
-          objects.each do |obj|
+          eo[:rows].each do |obj|
             parent_map[obj[prkey]] = obj
             (children_map[obj[key]] ||= []) << obj
             obj.associations[ancestors] = []
@@ -164,7 +164,7 @@ module Sequel
              model.join(t, key=>prkey).
              select(SQL::QualifiedIdentifier.new(t, ka), c_all)),
            r.select,
-           associations).all do |obj|
+           eo[:associations], eo).all do |obj|
             opk = obj[prkey]
             if in_pm = parent_map.has_key?(opk)
               if idm_obj = parent_map[opk]
@@ -224,11 +224,12 @@ module Sequel
           end
         end
         d[:after_load] = dal
-        d[:eager_loader] ||= proc do |key_hash, objects, associations|
-          id_map = key_hash[prkey]
+        d[:eager_loader] ||= proc do |eo|
+          id_map = eo[:key_hash][prkey]
+          associations = eo[:associations]
           parent_map = {}
           children_map = {}
-          objects.each do |obj|
+          eo[:rows].each do |obj|
             parent_map[obj[prkey]] = obj
             obj.associations[descendants] = []
             obj.associations[childrena] = []
@@ -248,7 +249,7 @@ module Sequel
           model.eager_loading_dataset(r,
            model.from(t).with_recursive(t, base_case, recursive_case),
            r.select,
-           associations).all do |obj|
+           associations, eo).all do |obj|
             if level
               no_cache = no_cache_level == obj.values.delete(la)
             end

data/lib/sequel/plugins/schema.rb

@@ -8,6 +8,14 @@ module Sequel
     # This plugin is mostly suited to test code.  If there is any
     # chance that your application's schema could change, you should
     # be using the migration extension instead.
+    # 
+    # Usage:
+    #
+    #   # Add the schema methods to all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :schema
+    #
+    #   # Add the schema methods to the Album class
+    #   Album.plugin :schema
     module Schema
       module ClassMethods
         # Creates table, using the column information from set_schema.

data/lib/sequel/plugins/serialization.rb

@@ -117,10 +117,8 @@ module Sequel
 
         # Serialize all deserialized values
         def before_save
+          deserialized_values.each{|k,v| @values[k] = serialize_value(k, v)}
           super
-          deserialized_values.each do |k,v|
-            @values[k] = serialize_value(k, v)
-          end
         end
         
         # Empty the deserialized values when refreshing.

data/lib/sequel/plugins/sharding.rb

@@ -0,0 +1,135 @@
+module Sequel
+  module Plugins
+    # The sharding plugin makes it easy to use Sequel's sharding features
+    # with models.  It lets you create model objects on specific shards,
+    # and any models retrieved from specific shards are automatically
+    # saved back to those shards.  It also works with associations,
+    # so that model objects retrieved from specific shards will only
+    # return associated objects from that shard, and using the
+    # add/remove/remove_all association methods will only affect
+    # that shard.
+    # 
+    # Usage:
+    #
+    #   # Add the sharding support to all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :sharding
+    #
+    #   # Add the sharding support to the Album class
+    #   Album.plugin :sharding
+    module Sharding
+      module ClassMethods
+        # Create a new object on the given shard s.
+        def create_using_server(s, values={}, &block)
+          new_using_server(s, values, &block).save
+        end
+
+        # When eagerly loading, if the current dataset has a defined shard and the
+        # dataset that you will be using to get the associated records does not,
+        # use the current dataset's shard for the associated dataset.
+        def eager_loading_dataset(opts, ds, select, associations, eager_options={})
+          ds = super(opts, ds, select, associations, eager_options)
+          if !ds.opts[:server] and s = eager_options[:self] and server = s.opts[:server]
+            ds = ds.server(server)
+          end
+          ds
+        end
+
+        # Return a newly instantiated object that is tied to the given
+        # shard s.  When the object is saved, a record will be inserted
+        # on shard s.
+        def new_using_server(s, values={}, &block)
+          new(values, &block).set_server(s)
+        end
+      end
+
+      module InstanceMethods
+        # Set the shard that this object is tied to.  Returns self.
+        def set_server(s)
+          @server = s
+          self
+        end
+
+        # Set the server that this object is tied to, unless it has
+        # already been set.  Returns self.
+        def set_server?(s)
+          @server ||= s
+          self
+        end
+
+        # Ensure that the instance dataset is tied to the correct shard.
+        def this
+          use_server(super)
+        end
+
+        private
+
+        # Ensure that association datasets are tied to the correct shard.
+        def _apply_association_options(*args)
+          use_server(super)
+        end
+
+        # Ensure that the object is inserted into the correct shard.
+        def _insert_dataset
+          use_server(super)
+        end
+
+        # Ensure that the join table for many_to_many associations uses the correct shard.
+        def _join_table_dataset(opts)
+          use_server(super)
+        end
+
+        # Make sure to use the correct shard when using a transaction
+        def checked_transaction(opts={}, &block)
+          super(@server ? {:server=>@server}.merge(opts) : opts, &block)
+        end
+
+        # If creating the object by doing <tt>add_association</tt> for a
+        # +many_to_many+ association, make sure the associated object is created on the
+        # current object's shard, unless the passed object already has an assigned shard.
+        def ensure_associated_primary_key(opts, o, *args)
+          o.set_server?(@server) if o.respond_to?(:set_server?)
+          super
+        end
+
+        # Set the given dataset to use the current object's shard.
+        def use_server(ds)
+          @server ? ds.server(@server) : ds
+        end
+      end
+
+      module DatasetMethods
+        # If a row proc exists on the dataset, replace it with one that calls the
+        # previous row_proc, but calls set_server on the output of that row_proc,
+        # ensuring that objects retrieved by a specific shard know which shard they
+        # are tied to.
+        def server(s)
+          ds = super
+          if rp = row_proc
+            ds.row_proc = proc{|r| rp.call(r).set_server(s)}
+          end
+          ds
+        end
+
+        private
+
+        # Set the shard of all retrieved objects to the shard of
+        # the table's dataset, or the current shard if the table's
+        # dataset does not have a shard.
+        def graph_each
+          ta = @opts[:graph][:table_aliases]
+          s = @opts[:server]
+          super do |r|
+            r.each do |k, v|
+              if ds = ta[k]
+                dss = ds.opts[:server]
+              end
+              vs = dss || s
+              v.set_server(vs) if vs && v.respond_to?(:set_server)
+            end
+            yield r
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -1,27 +1,76 @@
 module Sequel
   module Plugins
-    # Sequel's built in Single Table Inheritance plugin makes subclasses
-    # of this model only load rows where the given key field matches the
-    # subclass's name.  If the key given has a NULL value or there are
-    # any problems looking up the class, uses the current class.
+    # The single_table_inheritance plugin allows storing all objects
+    # in the same class hierarchy in the same table.  It makes it so
+    # subclasses of this model only load rows related to the subclass,
+    # and when you retrieve rows from the main class, you get instances
+    # of the subclasses (if the rows should use the subclasses's class).
+    #
+    # By default, the plugin assumes that the +sti_key+ column (the first
+    # argument to the plugin) holds the class name as a string.  However,
+    # you can override this by using the <tt>:model_map</tt> option and/or
+    # the <tt>:key_map</tt> option.
     #   
-    # You should only use this in the parent class, not in the subclasses.
+    # You should only load this plugin in the parent class, not in the subclasses.
     #   
     # You shouldn't call set_dataset in the model after applying this
-    # plugin, otherwise subclasses might use the wrong dataset.
+    # plugin, otherwise subclasses might use the wrong dataset. You should
+    # make sure this plugin is loaded before the subclasses. Note that since you
+    # need to load the plugin before the subclasses are created, you can't use
+    # direct class references in the plugin class.  You should specify subclasses
+    # in the plugin call using class name strings or symbols, see usage below.
     #   
-    # The filters and row_proc that sti_key sets up in subclasses may not work correctly if
-    # those subclasses have further subclasses.  For those middle subclasses,
-    # you may need to call set_dataset manually with the correct filter and
-    # row_proc.
+    # Usage:
+    #
+    #   # Use the default of storing the class name in the sti_key
+    #   # column (:kind in this case)
+    #   Employee.plugin :single_table_inheritance, :kind
+    #
+    #   # Using integers to store the class type, with a :model_map hash
+    #   # and an sti_key of :type
+    #   Employee.plugin :single_table_inheritance, :type,
+    #     :model_map=>{1=>:Staff, 2=>:Manager}
+    #
+    #   # Using non-class name strings
+    #   Employee.plugin :single_table_inheritance, :type,
+    #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager}
+    #
+    #   # Using custom procs, with :model_map taking column values
+    #   # and yielding either a class, string, symbol, or nil, 
+    #   # and :key_map taking a class object and returning the column
+    #   # value to use
+    #   Employee.plugin :single_table_inheritance, :type,
+    #     :model_map=>proc{|v| v.reverse},
+    #     :key_map=>proc{|klass| klass.name.reverse}
+    #
+    # One minor issue to note is that if you specify the <tt>:key_map</tt>
+    # option as a hash, instead of having it inferred from the <tt>:model_map</tt>,
+    # you should only use class name strings as keys, you should not use symbols
+    # as keys.
     module SingleTableInheritance
-      # Set the sti_key and sti_dataset for the model, and change the
-      # dataset's row_proc so that the dataset yields objects of varying classes,
-      # where the class used has the same name as the key field.
-      def self.configure(model, key)
+      # Setup the necessary STI variables, see the module RDoc for SingleTableInheritance
+      def self.configure(model, key, opts={})
         model.instance_eval do
+          @sti_key_array = nil
           @sti_key = key 
           @sti_dataset = dataset
+          @sti_model_map = opts[:model_map] || lambda{|v| v if v && v != ''}
+          @sti_key_map = if km = opts[:key_map]
+            if km.is_a?(Hash)
+              h = Hash.new{|h,k| h[k.to_s] unless k.is_a?(String)}
+              h.merge!(km)
+            else
+              km
+            end
+          elsif sti_model_map.is_a?(Hash)
+            h = Hash.new{|h,k| h[k.to_s] unless k.is_a?(String)}
+            sti_model_map.each do |k,v|
+              h[v.to_s] = k
+            end
+            h
+          else
+            lambda{|klass| klass.name.to_s}
+          end
           dataset.row_proc = lambda{|r| model.sti_load(r)}
         end
       end
@@ -34,17 +83,38 @@ module Sequel
         # The column name holding the STI key for this model
         attr_reader :sti_key
 
-        # Copy the sti_key and sti_dataset to the subclasses, and filter the
-        # subclass's dataset so it is restricted to rows where the key column
-        # matches the subclass's name.
+        # Array holding keys for all subclasses of this class, used for the
+        # dataset filter in subclasses. Nil in the main class.
+        attr_reader :sti_key_array
+
+        # A hash/proc with class keys and column value values, mapping
+        # the the class to a particular value given to the sti_key column.
+        # Used to set the column value when creating objects, and for the
+        # filter when retrieving objects in subclasses.
+        attr_reader :sti_key_map
+
+        # A hash/proc with column value keys and class values, mapping
+        # the value of the sti_key column to the appropriate class to use.
+        attr_reader :sti_model_map
+
+        # Copy the necessary attributes to the subclasses, and filter the
+        # subclass's dataset based on the sti_kep_map entry for the class.
         def inherited(subclass)
           super
           sk = sti_key
           sd = sti_dataset
-          subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>subclass.name.to_s), :inherited=>true)
+          skm = sti_key_map
+          smm = sti_model_map
+          key = skm[subclass] 
+          sti_subclass_added(key)
+          ska = [key]
+          subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>ska), :inherited=>true)
           subclass.instance_eval do
             @sti_key = sk
+            @sti_key_array = ska
             @sti_dataset = sd
+            @sti_key_map = skm
+            @sti_model_map = smm
             @simple_table = nil
           end
         end
@@ -52,21 +122,43 @@ module Sequel
         # Return an instance of the class specified by sti_key,
         # used by the row_proc.
         def sti_load(r)
-          v = r[sti_key]
-          model = if (v && v != '')
+          sti_class(sti_model_map[r[sti_key]]).load(r)
+        end
+
+        # Make sure that all subclasses of the parent class correctly include 
+        # keys for all of their descendant classes.
+        def sti_subclass_added(key)
+          if sti_key_array
+            sti_key_array << key
+            superclass.sti_subclass_added(key)
+          end
+        end
+
+        private
+
+        # Return a class object.  If a class is given, return it directly.
+        # Treat strings and symbols as class names.  If nil is given or
+        # an invalid class name string or symbol is used, return self.
+        # Raise an error for other types.
+        def sti_class(v)
+          case v
+          when String, Symbol
             constantize(v) rescue self
-          else
+          when nil
             self
+          when Class
+            v
+          else
+            raise(Error, "Invalid class type used: #{v.inspect}")
           end
-          model.load(r)
         end
       end
 
       module InstanceMethods
-        # Set the sti_key column to the name of the model.
+        # Set the sti_key column based on the sti_key_map.
         def before_create
-          return false if super == false
-          send("#{model.sti_key}=", model.name.to_s) unless send(model.sti_key)
+          send("#{model.sti_key}=", model.sti_key_map[model]) unless send(model.sti_key)
+          super
         end
       end
     end

data/lib/sequel/plugins/skip_create_refresh.rb

@@ -0,0 +1,35 @@
+module Sequel
+  module Plugins
+    # SkipCreateRefresh is a simple plugin that make Sequel not
+    # refresh after saving a new model object.  Sequel does the
+    # refresh to make sure all columns are populated, which is
+    # necessary so that database defaults work correctly.
+    #
+    # This plugin is mostly for performance reasons where you
+    # want to save the cost of select statement after the insert,
+    # but it could also help cases where records are not
+    # immediately available for selection after insertion.
+    #
+    # Note that Sequel does not attempt to refresh records when
+    # updating existing model objects, only when inserting new
+    # model objects.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances skip refreshes when saving
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :skip_create_refresh
+    #
+    #   # Make the Album class skip refreshes when saving
+    #   Album.plugin :skip_create_refresh
+    module SkipCreateRefresh
+      module InstanceMethods
+        private
+        # Do nothing instead of refreshing the record inside of save.
+        def _save_refresh
+          nil
+        end
+      end
+    end
+  end
+end