sequel 3.48.0 → 4.0.0

data/lib/sequel/plugins/pg_typecast_on_load.rb

@@ -7,7 +7,7 @@ module Sequel
     # the additional support that the pg_* extensions add for advanced PostgreSQL
     # types such as arrays.
     #
-    # This plugin modifies Model#set_values to do the same conversion that the
+    # This plugin makes model loading to do the same conversion that the
     # native postgres adapter would do for all columns given.  You can either
     # specify the columns to typecast on load in the plugin call itself, or
     # afterwards using add_pg_typecast_on_load_columns:
@@ -41,19 +41,35 @@ module Sequel
           @pg_typecast_on_load_columns.concat(columns)
         end
 
-        Plugins.inherited_instance_variables(self, :@pg_typecast_on_load_columns=>:dup)
-      end
+        def call(values)
+          super(load_typecast_pg(values))
+        end
 
-      module InstanceMethods
         # Lookup the conversion proc for the column's oid in the Database
         # object, and use it to convert the value.
-        def set_values(values)
-          model.pg_typecast_on_load_columns.each do |c|
+        def load_typecast_pg(values)
+          pg_typecast_on_load_columns.each do |c|
             if (v = values[c]).is_a?(String) && (oid = db_schema[c][:oid]) && (pr = db.conversion_procs[oid])
               values[c] = pr.call(v)
             end
           end
-          super
+          values
+        end
+
+        Plugins.inherited_instance_variables(self, :@pg_typecast_on_load_columns=>:dup)
+      end
+
+      module InstanceMethods
+        private
+
+        # Typecast specific columns using the conversion procs when manually refreshing.
+        def _refresh_set_values(values)
+          super(model.load_typecast_pg(values))
+        end
+
+        # Typecast specific columns using the conversion procs when refreshing after save.
+        def _save_set_values(values)
+          super(model.load_typecast_pg(values))
         end
       end
     end

data/lib/sequel/plugins/prepared_statements.rb

@@ -42,7 +42,7 @@ module Sequel
 
         # Create a prepared statement based on the given dataset with a unique name for the given
         # type of query and values.
-        def prepare_statement(ds, type, vals={})
+        def prepare_statement(ds, type, vals=OPTS)
           ps = ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
           ps.log_sql = true
           ps

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -25,8 +25,8 @@ module Sequel
       module ClassMethods
         # Disable prepared statement use if a block is given, or the :dataset or :conditions
         # options are used, or you are cloning an association.
-        def associate(type, name, opts = {}, &block)
-          if block || opts[:dataset] || opts[:conditions] || (opts[:clone] && association_reflection(opts[:clone])[:prepared_statement] == false)
+        def associate(type, name, opts = OPTS, &block)
+          if block || opts[:dataset] || (opts[:clone] && association_reflection(opts[:clone])[:prepared_statement] == false)
             opts = opts.merge(:prepared_statement=>false)
           end
           super(type, name, opts, &block)
@@ -48,7 +48,7 @@ module Sequel
           case opts[:type]
           when :many_to_one
             association_bound_variable_hash(opts.associated_class.table_name, opts.primary_keys, opts[:keys])
-          when :one_to_many
+          when :one_to_many, :one_to_one
             association_bound_variable_hash(opts.associated_class.table_name, opts[:keys], opts[:primary_keys])
           when :many_to_many
             association_bound_variable_hash(opts.join_table_alias, opts[:left_keys], opts[:left_primary_keys])
@@ -59,10 +59,18 @@ module Sequel
 
         # Given an association reflection, return and cache a prepared statement for this association such
         # that, given appropriate bound variables, the prepared statement will work correctly for any
-        # instance.
-        def association_prepared_statement(opts)
+        # instance.  Return false if such a prepared statement cannot be created.
+        def association_prepared_statement(opts, assoc_bv)
           opts.send(:cached_fetch, :prepared_statement) do
-            ps = _associated_dataset(opts, {}).unbind.first.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
+            ds, bv = _associated_dataset(opts, {}).unbind
+            if bv.length != assoc_bv.length
+              h = {}
+              bv.each do |k,v|
+                h[k] = v unless assoc_bv.has_key?(k)
+              end
+              ds = ds.bind(h)
+            end
+            ps = ds.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
             ps.log_sql = true
             ps
           end
@@ -70,15 +78,13 @@ module Sequel
 
         # If a prepared statement can be used to load the associated objects, execute it to retrieve them.  Otherwise,
         # fall back to the default implementation.
-        def _load_associated_objects(opts, dynamic_opts={})
-          if !opts.can_have_associated_objects?(self) || dynamic_opts[:callback] || (ps = opts[:prepared_statement]) == false
+        def _load_associated_objects(opts, dynamic_opts=OPTS)
+          if !opts.can_have_associated_objects?(self) || dynamic_opts[:callback] || (load_with_primary_key_lookup?(opts, dynamic_opts) && opts.associated_class.respond_to?(:cache_get_pk))
+            super
+          elsif (bv = association_bound_variables(opts)) && (ps ||= association_prepared_statement(opts, bv))
+            ps.call(bv)
+          else
             super
-          else 
-            if bv = association_bound_variables(opts)
-              (ps || association_prepared_statement(opts)).call(bv)
-            else
-              super
-            end
           end
         end
       end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -57,14 +57,14 @@ module Sequel
         # of free columns.
         def before_create
           if v = model.prepared_statements_column_defaults
-            set_values(v.merge(values))
+            @values = v.merge(values)
           end
           super
         end
 
         # Always do a full save of all columns to reduce the number of prepared
         # statements that can be used.
-        def save_changes(opts={})
+        def save_changes(opts=OPTS)
           save(opts) || false if modified?
         end
       end

data/lib/sequel/plugins/rcte_tree.rb

@@ -92,7 +92,7 @@ module Sequel
     module RcteTree
       # Create the appropriate parent, children, ancestors, and descendants
       # associations for the model.
-      def self.apply(model, opts={})
+      def self.apply(model, opts=OPTS)
         model.plugin :tree, opts
 
         opts = opts.dup

data/lib/sequel/plugins/serialization.rb

@@ -172,19 +172,20 @@ module Sequel
           @deserialized_values ||= {}
         end
 
+        # Freeze the deserialized values
         def freeze
           deserialized_values.freeze
           super
         end
 
-        # Initialization the deserialized values for objects retrieved from the database.
-        def set_values(hash)
+        private
+
+        # Clear any cached deserialized values when doing a manual refresh.
+        def _refresh_set_values(hash)
           @deserialized_values.clear if @deserialized_values
           super
         end
 
-        private
-
         # Deserialize the column value.  Called when the model column accessor is called to
         # return a deserialized value.
         def deserialize_value(column, v)

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -34,7 +34,7 @@ module Sequel
         # show the column is modified after saving.
         def after_save
           super
-          @original_deserialized_values = {}
+          @original_deserialized_values = @deserialized_values
         end
 
         # Detect which serialized columns have changed.

data/lib/sequel/plugins/sharding.rb

@@ -27,7 +27,7 @@ module Sequel
         # 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={})
+        def eager_loading_dataset(opts, ds, select, associations, eager_options=OPTS)
           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)
@@ -82,6 +82,12 @@ module Sequel
           o.set_server?(@server) if o.respond_to?(:set_server?)
           super
         end
+
+        # Don't use primary key lookup to load associated objects, since that will not
+        # respect the current object's server.
+        def load_with_primary_key_lookup?(opts, dynamic_opts)
+          false
+        end
       end
 
       module DatasetMethods

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -69,7 +69,7 @@ module Sequel
     # as keys.
     module SingleTableInheritance
       # Setup the necessary STI variables, see the module RDoc for SingleTableInheritance
-      def self.configure(model, key, opts={})
+      def self.configure(model, key, opts=OPTS)
         model.instance_eval do
           @sti_key_array = nil
           @sti_key = key 

data/lib/sequel/plugins/timestamps.rb

@@ -26,7 +26,7 @@ module Sequel
       # * :force - Whether to overwrite an existing create timestamp (default: false)
       # * :update - The field to hold the update timestamp (default: :updated_at)
       # * :update_on_create - Whether to set the update timestamp to the create timestamp when creating (default: false)
-      def self.configure(model, opts={})
+      def self.configure(model, opts=OPTS)
         model.instance_eval do
           @create_timestamp_field = opts[:create]||:created_at
           @update_timestamp_field = opts[:update]||:updated_at

data/lib/sequel/plugins/touch.rb

@@ -30,7 +30,7 @@ module Sequel
       # The default column to update when touching
       TOUCH_COLUMN_DEFAULT = :updated_at
 
-      def self.apply(model, opts={})
+      def self.apply(model, opts=OPTS)
         model.instance_variable_set(:@touched_associations, {})
       end
 
@@ -43,7 +43,7 @@ module Sequel
       #   when updating the associated objects is the model's touch_column.
       #   If a hash is used, the value is used as the column to update.
       # * :column - The column to modify when touching a model instance.
-      def self.configure(model, opts={})
+      def self.configure(model, opts=OPTS)
         model.touch_column = opts[:column] || TOUCH_COLUMN_DEFAULT if opts[:column] || !model.touch_column
         model.touch_associations(opts[:associations]) if opts[:associations]
       end

data/lib/sequel/plugins/tree.rb

@@ -27,7 +27,7 @@ module Sequel
       # specify options to use for the parent association
       # using a :parent option, and options to use for the
       # children association using a :children option.
-      def self.apply(model, opts={})
+      def self.apply(model, opts=OPTS)
         opts = opts.dup
         opts[:class] = model
 

data/lib/sequel/plugins/typecast_on_load.rb

@@ -5,7 +5,7 @@ module Sequel
     # typecast correctly (with correct being defined as how the model object
     # would typecast the same column values).
     #
-    # This plugin modifies Model#set_values to call the setter methods (which typecast
+    # This plugin makes model loading call the setter methods (which typecast
     # by default) for all columns given.  You can either specify the columns to
     # typecast on load in the plugin call itself, or afterwards using 
     # add_typecast_on_load_columns:
@@ -36,6 +36,12 @@ module Sequel
           @typecast_on_load_columns.concat(columns)
         end
 
+        # Typecast values using #load_typecast when the values are retrieved
+        # from the database.
+        def call(values)
+          super.load_typecast
+        end
+
         Plugins.inherited_instance_variables(self, :@typecast_on_load_columns=>:dup)
       end
 
@@ -52,9 +58,18 @@ module Sequel
           self
         end
 
-        # Typecast values using #load_typecast when the values are retrieved from
-        # the database.
-        def set_values(values)
+        private
+
+        # Typecast values using #load_typecast when the values are refreshed manually.
+        def _refresh_set_values(values)
+          ret = super
+          load_typecast
+          ret
+        end
+
+        # Typecast values using #load_typecast when the values are refreshed
+        # automatically after a save.
+        def _save_set_values(values)
           ret = super
           load_typecast
           ret

data/lib/sequel/plugins/validation_class_methods.rb

@@ -264,36 +264,6 @@ module Sequel
           end
         end
     
-        # Validates whether an attribute is not a string.  This is generally useful
-        # in conjunction with raise_on_typecast_failure = false, where you are
-        # passing in string values for non-string attributes (such as numbers and dates).
-        # If typecasting fails (invalid number or date), the value of the attribute will
-        # be a string in an invalid format, and if typecasting succeeds, the value will
-        # not be a string.
-        #
-        # Possible Options:
-        # * :message - The message to use (default: 'is a string' or 'is not a valid (integer|datetime|etc.)' if the type is known)
-        def validates_not_string(*atts)
-          Sequel::Deprecation.deprecate('validates_not_string', "Please switch to validates_schema_type")
-          opts = {
-            :tag => :not_string,
-          }.merge!(extract_options!(atts))
-          reflect_validation(:not_string, opts, atts)
-          atts << opts
-          validates_each(*atts) do |o, a, v|
-            if v.is_a?(String)
-              unless message = opts[:message]
-                message = if sch = o.db_schema[a] and typ = sch[:type]
-                  "is not a valid #{typ}"
-                else
-                  "is a string"
-                end
-              end
-              o.errors.add(a, message)
-            end
-          end
-        end
-    
         # Validates whether an attribute is a number.
         #
         # Possible Options:

data/lib/sequel/plugins/validation_helpers.rb

@@ -32,9 +32,7 @@ module Sequel
     # :allow_nil :: Whether to skip the validation if the value is nil.
     # :message :: The message to use.  Can be a string which is used directly, or a
     #             proc which is called.  If the validation method takes a argument before the array of attributes,
-    #             that argument is passed as an argument to the proc.  The exception is the
-    #             validates_not_string method, which doesn't take an argument, but passes
-    #             the schema type symbol as the argument to the proc.
+    #             that argument is passed as an argument to the proc.
     #
     # The default validation options for all models can be modified by
     # changing the values of the Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS hash.  You
@@ -84,7 +82,6 @@ module Sequel
         :max_length=>{:message=>lambda{|max| "is longer than #{max} characters"}, :nil_message=>lambda{"is not present"}},
         :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
         :not_null=>{:message=>lambda{"is not present"}},
-        :not_string=>{:message=>lambda{|type| type ? "is not a valid #{type}" : "is a string"}},
         :numeric=>{:message=>lambda{"is not a number"}},
         :type=>{:message=>lambda{|klass| klass.is_a?(Array) ? "is not a valid #{klass.join(" or ").downcase}" : "is not a valid #{klass.to_s.downcase}"}},
         :presence=>{:message=>lambda{"is not present"}},
@@ -93,22 +90,22 @@ module Sequel
 
       module InstanceMethods 
         # Check that the attribute values are the given exact length.
-        def validates_exact_length(exact, atts, opts={})
+        def validates_exact_length(exact, atts, opts=OPTS)
           validatable_attributes_for_type(:exact_length, atts, opts){|a,v,m| validation_error_message(m, exact) if v.nil? || v.length != exact}
         end
 
         # Check the string representation of the attribute value(s) against the regular expression with.
-        def validates_format(with, atts, opts={})
+        def validates_format(with, atts, opts=OPTS)
           validatable_attributes_for_type(:format, atts, opts){|a,v,m| validation_error_message(m, with) unless v.to_s =~ with}
         end
     
         # Check attribute value(s) is included in the given set.
-        def validates_includes(set, atts, opts={})
+        def validates_includes(set, atts, opts=OPTS)
           validatable_attributes_for_type(:includes, atts, opts){|a,v,m| validation_error_message(m, set) unless set.send(set.respond_to?(:cover?) ? :cover? : :include?, v)}
         end
     
         # Check attribute value(s) string representation is a valid integer.
-        def validates_integer(atts, opts={})
+        def validates_integer(atts, opts=OPTS)
           validatable_attributes_for_type(:integer, atts, opts) do |a,v,m|
             begin
               Kernel.Integer(v.to_s)
@@ -120,7 +117,7 @@ module Sequel
         end
 
         # Check that the attribute values length is in the specified range.
-        def validates_length_range(range, atts, opts={})
+        def validates_length_range(range, atts, opts=OPTS)
           validatable_attributes_for_type(:length_range, atts, opts){|a,v,m| validation_error_message(m, range) if v.nil? || !range.send(range.respond_to?(:cover?) ? :cover? : :include?, v.length)}
         end
     
@@ -128,33 +125,22 @@ module Sequel
         #
         # Accepts a :nil_message option that is the error message to use when the
         # value is nil instead of being too long.
-        def validates_max_length(max, atts, opts={})
+        def validates_max_length(max, atts, opts=OPTS)
           validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| v ? validation_error_message(m, max) : validation_error_message(opts[:nil_message] || DEFAULT_OPTIONS[:max_length][:nil_message]) if v.nil? || v.length > max}
         end
 
         # Check that the attribute values are not shorter than the given min length.
-        def validates_min_length(min, atts, opts={})
+        def validates_min_length(min, atts, opts=OPTS)
           validatable_attributes_for_type(:min_length, atts, opts){|a,v,m| validation_error_message(m, min) if v.nil? || v.length < min}
         end
 
         # Check attribute value(s) are not NULL/nil.
-        def validates_not_null(atts, opts={})
+        def validates_not_null(atts, opts=OPTS)
           validatable_attributes_for_type(:not_null, atts, opts){|a,v,m| validation_error_message(m) if v.nil?}
         end
         
-        # Check that the attribute value(s) is not a string.  This is generally useful
-        # in conjunction with raise_on_typecast_failure = false, where you are
-        # passing in string values for non-string attributes (such as numbers and dates).
-        # If typecasting fails (invalid number or date), the value of the attribute will
-        # be a string in an invalid format, and if typecasting succeeds, the value will
-        # not be a string.
-        def validates_not_string(atts, opts={})
-          Sequel::Deprecation.deprecate('validates_not_string', "Please switch to validates_schema_types")
-          validatable_attributes_for_type(:not_string, atts, opts){|a,v,m| validation_error_message(m, (db_schema[a]||{})[:type]) if v.is_a?(String)}
-        end
-
         # Check attribute value(s) string representation is a valid float.
-        def validates_numeric(atts, opts={})
+        def validates_numeric(atts, opts=OPTS)
           validatable_attributes_for_type(:numeric, atts, opts) do |a,v,m|
             begin
               Kernel.Float(v.to_s)
@@ -168,7 +154,7 @@ module Sequel
         # Validates for all of the model columns (or just the given columns)
         # that the column value is an instance of the expected class based on
         # the column's schema type.
-        def validates_schema_types(atts=keys, opts={})
+        def validates_schema_types(atts=keys, opts=OPTS)
           Array(atts).each do |k|
             if type = schema_type_class(k)
               validates_type(type, k, {:allow_nil=>true}.merge(opts))
@@ -178,13 +164,9 @@ module Sequel
 
         # Check if value is an instance of a class.  If +klass+ is an array,
         # the value must be an instance of one of the classes in the array.
-        def validates_type(klass, atts, opts={})
+        def validates_type(klass, atts, opts=OPTS)
           klass = klass.to_s.constantize if klass.is_a?(String) || klass.is_a?(Symbol)
           validatable_attributes_for_type(:type, atts, opts) do |a,v,m|
-            if v.nil?
-              Sequel::Deprecation.deprecate('validates_type will no longer allow nil values by default in Sequel 4.  Use the :allow_nil=>true option to allow nil values.')
-              next
-            end
             if klass.is_a?(Array) ? !klass.any?{|kls| v.is_a?(kls)} : !v.is_a?(klass)
               validation_error_message(m, klass)
             end
@@ -192,7 +174,7 @@ module Sequel
         end
 
         # Check attribute value(s) is not considered blank by the database, but allow false values.
-        def validates_presence(atts, opts={})
+        def validates_presence(atts, opts=OPTS)
           validatable_attributes_for_type(:presence, atts, opts){|a,v,m| validation_error_message(m) if model.db.send(:blank_object?, v) && v != false}
         end