sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/rcte_tree.rb

@@ -12,26 +12,6 @@ module Sequel
     # level (where level 1 is children, level 2 is children and grandchildren
     # etc.) in a single query.
     #
-    # = Background
-    # 
-    # There are two types of common models for storing tree structured data
-    # in an SQL database, the adjacency list model and the nested set model.
-    # Before recursive common table expressions (or similar capabilities such
-    # as CONNECT BY for Oracle), the nested set model was the only easy way
-    # to retrieve all ancestors and descendants in a single query.  However,
-    # it has significant performance corner cases.
-    #
-    # On PostgreSQL 8.4, with a significant number of rows, the nested set
-    # model is almost 500 times slower than using a recursive common table
-    # expression with the adjacency list model to get all descendants, and
-    # almost 24,000 times slower to get all descendants to a given level.
-    #
-    # Considering that the nested set model requires more difficult management
-    # than the adjacency list model, it's almost always better to use the
-    # adjacency list model if your database supports common table expressions.
-    # See http://explainextended.com/2009/09/24/adjacency-list-vs-nested-sets-postgresql/
-    # for detailed analysis.
-    #
     # = Usage
     #
     # The rcte_tree plugin adds four associations to the model: parent, children, ancestors, and
@@ -56,12 +36,12 @@ module Sequel
     #   
     #   # Eager loading - also populates the :parent and children associations
     #   # for all ancestors and descendants
-    #   Model.filter(:id=>[1, 2]).eager(:ancestors, :descendants).all
+    #   Model.where(id: [1, 2]).eager(:ancestors, :descendants).all
     #   
-    #   # Eager loading children and grand children
-    #   Model.filter(:id=>[1, 2]).eager(:descendants=>2).all
-    #   # Eager loading children, grand children, and great grand children
-    #   Model.filter(:id=>[1, 2]).eager(:descendants=>3).all
+    #   # Eager loading children and grandchildren
+    #   Model.where(id: [1, 2]).eager(descendants: 2).all
+    #   # Eager loading children, grandchildren, and great grandchildren
+    #   Model.where(id: [1, 2]).eager(descendants: 3).all
     #
     # = Options
     #
@@ -76,8 +56,8 @@ module Sequel
     # Note that you can change the name of the above associations by specifying
     # a :name key in the appropriate hash of options above.  For example:
     #
-    #   Model.plugin :rcte_tree, :parent=>{:name=>:mother},
-    #    :children=>{:name=>:daughters}, :descendants=>{:name=>:offspring}
+    #   Model.plugin :rcte_tree, parent: {name: :mother},
+    #    children: {name: :daughters}, descendants: {name: :offspring}
     #
     # Any other keys in the main options hash are treated as options shared by
     # all of the associations.  Here's a few options that affect the plugin:
@@ -125,7 +105,6 @@ module Sequel
           key_present = lambda{|m| key_conv[m].all?}
           prkey_conv = lambda{|m| prkey_array.map{|k| m[k]}}
           key_aliases = (0...key_array.length).map{|i| :"#{ka}_#{i}"}
-          ka_conv = lambda{|m| key_aliases.map{|k| m[k]}}
           ancestor_base_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           descendant_base_case_columns = key_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           recursive_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::QualifiedIdentifier.new(t, ka_)} + c_all
@@ -134,27 +113,29 @@ module Sequel
           key_present = key_conv = lambda{|m| m[key]}
           prkey_conv = lambda{|m| m[prkey]}
           key_aliases = [ka]
-          ka_conv = lambda{|m| m[ka]}
           ancestor_base_case_columns = [SQL::AliasedExpression.new(prkey, ka)] + c_all
           descendant_base_case_columns = [SQL::AliasedExpression.new(key, ka)] + c_all
           recursive_case_columns = [SQL::QualifiedIdentifier.new(t, ka)] + c_all
           extract_key_alias = lambda{|m| bd_conv[m.values.delete(ka)]}
         end
         
-        parent = opts.merge(opts.fetch(:parent, {})).fetch(:name, :parent)
-        childrena = opts.merge(opts.fetch(:children, {})).fetch(:name, :children)
+        parent = opts.merge(opts.fetch(:parent, OPTS)).fetch(:name, :parent)
+        childrena = opts.merge(opts.fetch(:children, OPTS)).fetch(:name, :children)
         
         opts[:reciprocal] = nil
-        a = opts.merge(opts.fetch(:ancestors, {}))
+        a = opts.merge(opts.fetch(:ancestors, OPTS))
         ancestors = a.fetch(:name, :ancestors)
         a[:read_only] = true unless a.has_key?(:read_only)
+        a[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{ancestors} association for #{self} does not support eager graphing"
+        end
         a[:eager_loader_key] = key
         a[:dataset] ||= proc do
-          base_ds = model.filter(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
+          base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, key_array.zip(prkey_array))
           if c = a[:conditions]
-            (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -189,20 +170,22 @@ module Sequel
           id_map = eo[:id_map]
           parent_map = {}
           children_map = {}
-          eo[:rows].each do |obj|
-            parent_map[prkey_conv[obj]] = obj
-            (children_map[key_conv[obj]] ||= []) << obj
-            obj.associations[ancestors] = []
-            obj.associations[parent] = nil
+          Sequel.synchronize_with(eo[:mutex]) do
+            eo[:rows].each do |obj|
+              parent_map[prkey_conv[obj]] = obj
+              (children_map[key_conv[obj]] ||= []) << obj
+              obj.associations[ancestors] = []
+              obj.associations[parent] = nil
+            end
           end
           r = model.association_reflection(ancestors)
-          base_case = model.filter(prkey=>id_map.keys).
+          base_case = model.where(prkey=>id_map.keys).
            select(*ancestor_base_case_columns)
           recursive_case = model.join(t, key_array.zip(prkey_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
-            (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -211,45 +194,46 @@ module Sequel
              :args=>((key_aliases + col_aliases) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
             opk = prkey_conv[obj]
-            if parent_map.has_key?(opk)
-              if idm_obj = parent_map[opk]
-                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
-                obj = idm_obj
-              end
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              obj = idm_obj
             else
               obj.associations[parent] = nil
               parent_map[opk] = obj
               (children_map[key_conv[obj]] ||= []) << obj
             end
             
-            if roots = id_map[extract_key_alias[obj]]
-              roots.each do |root|
-                root.associations[ancestors] << obj
-              end
+            id_map[extract_key_alias[obj]].each do |root|
+              root.associations[ancestors] << obj
             end
           end
-          parent_map.each do |parent_id, obj|
-            if children = children_map[parent_id]
-              children.each do |child|
-                child.associations[parent] = obj
+          Sequel.synchronize_with(eo[:mutex]) do
+            parent_map.each do |parent_id, obj|
+              if children = children_map[parent_id]
+                children.each do |child|
+                  child.associations[parent] = obj
+                end
               end
             end
           end
         end
         model.one_to_many ancestors, a
         
-        d = opts.merge(opts.fetch(:descendants, {}))
+        d = opts.merge(opts.fetch(:descendants, OPTS))
         descendants = d.fetch(:name, :descendants)
         d[:read_only] = true unless d.has_key?(:read_only)
+        d[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{descendants} association for #{self} does not support eager graphing"
+        end
         la = d[:level_alias] ||= :x_level_x
         d[:dataset] ||= proc do
-          base_ds = model.filter(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
+          base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, prkey_array.zip(key_array))
           if c = d[:conditions]
-            (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -288,27 +272,29 @@ module Sequel
           associations = eo[:associations]
           parent_map = {}
           children_map = {}
-          eo[:rows].each do |obj|
-            parent_map[prkey_conv[obj]] = obj
-            obj.associations[descendants] = []
-            obj.associations[childrena] = []
+          Sequel.synchronize_with(eo[:mutex]) do
+            eo[:rows].each do |obj|
+              parent_map[prkey_conv[obj]] = obj
+              obj.associations[descendants] = []
+              obj.associations[childrena] = []
+            end
           end
           r = model.association_reflection(descendants)
-          base_case = model.filter(key=>id_map.keys).
+          base_case = model.where(key=>id_map.keys).
            select(*descendant_base_case_columns)
           recursive_case = model.join(t, prkey_array.zip(key_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
-            (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           if associations.is_a?(Integer)
             level = associations
             no_cache_level = level - 1
             associations = {}
-            base_case = base_case.select_more(SQL::AliasedExpression.new(Sequel.cast(0, Integer), la))
-            recursive_case = recursive_case.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).filter(SQL::QualifiedIdentifier.new(t, la) < level - 1)
+            base_case = base_case.select_append(SQL::AliasedExpression.new(Sequel.cast(0, Integer), la))
+            recursive_case = recursive_case.select_append(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).where(SQL::QualifiedIdentifier.new(t, la) < level - 1)
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           ds = model.from(SQL::AliasedExpression.new(t, table_alias)).
@@ -316,17 +302,15 @@ module Sequel
               :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>{})) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
             if level
               no_cache = no_cache_level == obj.values.delete(la)
             end
             
             opk = prkey_conv[obj]
-            if parent_map.has_key?(opk)
-              if idm_obj = parent_map[opk]
-                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
-                obj = idm_obj
-              end
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              obj = idm_obj
             else
               obj.associations[childrena] = [] unless no_cache
               parent_map[opk] = obj
@@ -338,12 +322,14 @@ module Sequel
             
             (children_map[key_conv[obj]] ||= []) << obj
           end
-          children_map.each do |parent_id, objs|
-            objs = objs.uniq
-            parent_obj = parent_map[parent_id]
-            parent_obj.associations[childrena] = objs
-            objs.each do |obj|
-              obj.associations[parent] = parent_obj
+          Sequel.synchronize_with(eo[:mutex]) do
+            children_map.each do |parent_id, objs|
+              objs = objs.uniq
+              parent_obj = parent_map[parent_id]
+              parent_obj.associations[childrena] = objs
+              objs.each do |obj|
+                obj.associations[parent] = parent_obj
+              end
             end
           end
         end

data/lib/sequel/plugins/require_valid_schema.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The require_valid_schema plugin makes Sequel raise or warn if attempting
+    # to set the dataset of a model class to a simple table, where the database
+    # supports schema parsing, but schema parsing does not work for the model's
+    # table.
+    #
+    # The plugin's default behavior requires that all models that select from a
+    # single identifier have a valid table schema, if the database supports
+    # schema parsing. If the schema cannot be determined for such
+    # a model, an error is raised:
+    #   
+    #   Sequel::Model.plugin :require_valid_schema
+    #
+    # If you load the plugin with an argument of :warn, Sequel will warn instead
+    # of raising for such tables:
+    #
+    #   Sequel::Model.plugin :require_valid_schema, :warn
+    #
+    # This can catch bugs where you expect models to have valid schema, but
+    # they do not. This setting only affects future attempts to set datasets
+    # in the current class and subclasses created in the future.
+    #
+    # If you load the plugin with an argument of false, it will not require valid schema.
+    # This can be used in subclasses where you do not want to require valid schema,
+    # but the plugin must be loaded before a dataset with invalid schema is set:
+    #
+    #   Sequel::Model.plugin :require_valid_schema
+    #   InvalidSchemaAllowed = Class.new(Sequel::Model)
+    #   InvalidSchemaAllowed.plugin :require_valid_schema, false
+    #   class MyModel < InvalidSchemaAllowed
+    #   end
+    module RequireValidSchema
+      # Modify the current model's dataset selection, if the model
+      # has a dataset.
+      def self.configure(model, setting=true)
+        model.instance_variable_set(:@require_valid_schema, setting)
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@require_valid_schema=>nil)
+
+        private
+
+        # If the schema cannot be determined, the model uses a simple table,
+        # require_valid_schema is set, and the database supports schema parsing, raise or
+        # warn based on the require_valid_schema setting.
+        def get_db_schema_array(reload)
+          schema_array = super
+
+          if !schema_array && simple_table && @require_valid_schema
+            message = "Not able to parse schema for model: #{inspect}, table: #{simple_table}"
+            if @require_valid_schema == :warn
+              warn message
+            else
+              raise Error, message
+            end
+          end
+
+          schema_array
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/serialization.rb

@@ -2,16 +2,16 @@
 
 module Sequel
   module Plugins
-    # Sequel's built in Serialization plugin allows you to keep serialized
+    # The serialization plugin allows you to keep serialized
     # ruby objects in the database, while giving you deserialized objects
     # when you call an accessor.
     #
     # This plugin works by keeping the serialized value in the values, and
-    # adding a @deserialized_values hash.  The reader method for serialized columns
-    # will check the @deserialized_values for the value, return it if present,
-    # or deserialized the entry in @values and return it.  The writer method will
-    # set the @deserialized_values entry.  This plugin adds a before_save hook
-    # that serializes all @deserialized_values to @values.
+    # adding a deserialized_values hash.  The reader method for serialized columns
+    # will check the deserialized_values for the value, return it if present,
+    # or deserialize the entry in values and return it.  The writer method will
+    # set the deserialized_values entry.  This plugin adds a before_validation hook
+    # that serializes all deserialized_values to values.
     #
     # You can specify the serialization format as a pair of serializer/deserializer
     # callable objects.  You can also specify the serialization format as a single
@@ -37,9 +37,7 @@ module Sequel
     #
     #   # Register custom serializer/deserializer pair, if desired
     #   require 'sequel/plugins/serialization'
-    #   Sequel::Plugins::Serialization.register_format(:reverse,
-    #     lambda(&:reverse),
-    #     lambda(&:reverse))
+    #   Sequel::Plugins::Serialization.register_format(:reverse, :reverse.to_proc, :reverse.to_proc)
     #
     #   class User < Sequel::Model
     #     # Built-in format support when loading the plugin
@@ -53,10 +51,10 @@ module Sequel
     #     serialize_attributes :reverse, :password
     #
     #     # Use a custom serializer/deserializer pair without registering
-    #     serialize_attributes [lambda(&:reverse), lambda(&:reverse)], :password
+    #     serialize_attributes [:reverse.to_proc, :reverse.to_proc], :password
     #   end
     #   user = User.create
-    #   user.permissions = { :global => 'read-only' }
+    #   user.permissions = {global: 'read-only'}
     #   user.save
     #
     # Note that if you mutate serialized column values without reassigning them,
@@ -77,7 +75,7 @@ module Sequel
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
       def self.apply(model, *args)
-        model.instance_eval do
+        model.instance_exec do
           @deserialization_map = {}
           @serialization_map = {}
         end
@@ -93,23 +91,16 @@ module Sequel
       # models to pick this format by name.  Both serializer and deserializer
       # should be callable objects.
       def self.register_format(format, serializer, deserializer)
-        REGISTERED_FORMATS[format] = [serializer, deserializer]
+        Sequel.synchronize{REGISTERED_FORMATS[format] = [serializer, deserializer].freeze}
       end
       register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
         lambda do |v|
-          begin
-            Marshal.load(v.unpack('m')[0])
-          rescue => e
-            begin
-              # Backwards compatibility for unpacked marshal output.
-              Marshal.load(v)
-            rescue
-              raise e
-            end
-          end
+          # Handle unpacked marshalled data for backwards compat
+          v = v.unpack('m')[0] unless v[0..1] == "\x04\x08"
+          Marshal.load(v)
         end)
-      register_format(:yaml, lambda(&:to_yaml), lambda{|v| YAML.load(v)})
-      register_format(:json, lambda{|v| Sequel.object_to_json(v)}, lambda{|v| Sequel.parse_json(v)})
+      register_format(:yaml, :to_yaml.to_proc, lambda{|s| YAML.load(s)})
+      register_format(:json, Sequel.method(:object_to_json), Sequel.method(:parse_json))
 
       module ClassMethods
         # A hash with column name symbols and callable values, with the value
@@ -120,18 +111,23 @@ module Sequel
         # called to serialize the column.
         attr_reader :serialization_map
 
-        # Module to store the serialized column accessor methods, so they can
-        # call be overridden and call super to get the serialization behavior
-        attr_accessor :serialization_module
-
         Plugins.inherited_instance_variables(self, :@deserialization_map=>:dup, :@serialization_map=>:dup)
+
+        # Freeze serialization metadata when freezing model class.
+        def freeze
+          @deserialization_map.freeze
+          @serialization_map.freeze
+          @serialization_module.freeze if @serialization_module
+
+          super
+        end
         
         # Create instance level reader that deserializes column values on request,
         # and instance level writer that stores new deserialized values.
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
-            unless format = REGISTERED_FORMATS[format]
-              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{REGISTERED_FORMATS.keys.map(&:inspect).join})")
+            unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
+              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{Sequel.synchronize{REGISTERED_FORMATS.keys}.inspect})")
             end
           end
           serializer, deserializer = format
@@ -139,19 +135,13 @@ module Sequel
           define_serialized_attribute_accessor(serializer, deserializer, *columns)
         end
         
-        # The columns that will be serialized.  This is only for
-        # backwards compatibility, use serialization_map in new code.
-        def serialized_columns
-          serialization_map.keys
-        end
-
         private
 
         # Add serializated attribute acessor methods to the serialization_module
         def define_serialized_attribute_accessor(serializer, deserializer, *columns)
           m = self
-          include(self.serialization_module ||= Module.new) unless serialization_module
-          serialization_module.class_eval do
+          include(@serialization_module ||= Module.new) unless @serialization_module
+          @serialization_module.class_eval do
             columns.each do |column|
               m.serialization_map[column] = serializer
               m.deserialization_map[column] = deserializer
@@ -164,15 +154,20 @@ module Sequel
                   deserialized_values[column] = deserialize_value(column, super())
                 end
               end
-              define_method("#{column}=") do |v| 
-                if !changed_columns.include?(column) && (new? || get_column_value(column) != v)
-                  changed_columns << column
+              alias_method(column, column)
+
+              setter = :"#{column}="
+              define_method(setter) do |v| 
+                cc = changed_columns
+                if !cc.include?(column) && (new? || get_column_value(column) != v)
+                  cc << column
 
                   will_change_column(column) if respond_to?(:will_change_column)
                 end
 
                 deserialized_values[column] = v
               end
+              alias_method(setter, setter)
             end
           end
         end
@@ -186,18 +181,20 @@ module Sequel
 
         # Freeze the deserialized values
         def freeze
-          deserialized_values.freeze
+          deserialized_values
           super
+          deserialized_values.freeze
+          self
         end
 
-        private
-
         # Serialize deserialized values before saving
-        def _before_validation
+        def before_validation
           serialize_deserialized_values
           super
         end
         
+        private
+
         # Clear any cached deserialized values when doing a manual refresh.
         def _refresh_set_values(hash)
           @deserialized_values.clear if @deserialized_values

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -22,7 +22,7 @@ module Sequel
     #     plugin :serialization, :json, :permissions
     #     plugin :serialization_modification_detection
     #   end
-    #   user = User.create(:permissions => {})
+    #   user = User.create(permissions: {})
     #   user.permissions[:global] = 'read-only'
     #   user.save_changes
     module SerializationModificationDetection
@@ -50,8 +50,9 @@ module Sequel
         # Freeze the original deserialized values when freezing the instance.
         def freeze
           @original_deserialized_values ||= {}
-          @original_deserialized_values.freeze
           super
+          @original_deserialized_values.freeze
+          self
         end
 
         private

data/lib/sequel/plugins/sharding.rb

@@ -5,10 +5,9 @@ module Sequel
     # The sharding plugin augments Sequel's default model sharding support
     # in the following ways:
     #
-    # * It automatically sets model instances to be saved back to the
+    # * It automatically saves model instances back to the
     #   shard they were retreived from.
-    # * It makes model associations use the same shard as the model
-    #   object.
+    # * It makes model associations use the same shard as the model object.
     # * It adds a slightly nicer API for creating model instances on
     #   specific shards.
     # 
@@ -22,7 +21,7 @@ module Sequel
     module Sharding
       module ClassMethods
         # Create a new object on the given shard s.
-        def create_using_server(s, values={}, &block)
+        def create_using_server(s, values=OPTS, &block)
           new_using_server(s, values, &block).save
         end
 
@@ -46,7 +45,7 @@ module Sequel
         # 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)
+        def new_using_server(s, values=OPTS, &block)
           new(values, &block).set_server(s)
         end
 
@@ -108,12 +107,18 @@ module Sequel
         # 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)}
+        def row_proc
+          rp = super
+          if rp
+            case server = db.pool.send(:pick_server, opts[:server])
+            when nil, :default, :read_only
+              # nothing
+            else
+              old_rp = rp
+              rp = proc{|r| old_rp.call(r).set_server(server)}
+            end
           end
-          ds
+          rp 
         end
       end
     end