sequel 4.47.0 → 4.48.0

data/lib/sequel/plugins/association_pks.rb

@@ -41,6 +41,17 @@ module Sequel
     # If set to :remove, the setter will treat the nil as an empty array, removing
     # the association all currently associated values.
     #
+    # For many_to_many associations, association_pks assumes the related pks can be
+    # accessed directly from the join table.  This works in most cases, but in cases
+    # where the :right_primary_key association option is used to specify a different
+    # primary key in the associated table, association_pks will return the value of
+    # the association primary keys (foreign key values to associated table in the join
+    # table), not the associated model primary keys.  If you would like to use the
+    # associated model primary keys, you need to use the
+    # :association_pks_use_associated_table association option. If the
+    # :association_pks_use_associated_table association option is used, no setter
+    # method will be added.
+    #
     # Usage:
     #
     #   # Make all model subclass *_to_many associations have association_pks
@@ -57,7 +68,7 @@ module Sequel
         # Define a association_pks method using the block for the association reflection 
         def def_association_pks_methods(opts)
           association_module_def(:"#{singularize(opts[:name])}_pks", opts){_association_pks_getter(opts)}
-          association_module_def(:"#{singularize(opts[:name])}_pks=", opts){|pks| _association_pks_setter(opts, pks)} unless opts[:read_only]
+          association_module_def(:"#{singularize(opts[:name])}_pks=", opts){|pks| _association_pks_setter(opts, pks)} if opts[:pks_setter]
         end
 
         # Add a getter that checks the join table for matching records and
@@ -73,11 +84,23 @@ module Sequel
           clpk = lpk.is_a?(Array)
           crk = rk.is_a?(Array)
 
-          opts[:pks_getter] = if clpk
+          opts[:pks_getter] = if join_associated_table = opts[:association_pks_use_associated_table]
+            tname = opts[:join_table]
+            lambda do
+              cond = if clpk
+                lk.zip(lpk).map{|k, pk| [Sequel.qualify(tname, k), get_column_value(pk)]}
+              else
+                {Sequel.qualify(tname, lk) => get_column_value(lpk)}
+              end
+              rpk = opts.associated_class.primary_key
+              opts.associated_dataset.
+                naked.where(cond).
+                select_map(Sequel.send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
+            end
+          elsif clpk
             lambda do
-              h = {}
-              lk.zip(lpk).each{|k, pk| h[k] = get_column_value(pk)}
-              _join_table_dataset(opts).where(h).select_map(rk)
+              cond = lk.zip(lpk).map{|k, pk| [k, get_column_value(pk)]}
+              _join_table_dataset(opts).where(cond).select_map(rk)
             end
           else
             lambda do
@@ -85,25 +108,27 @@ module Sequel
             end
           end
 
-          opts[:pks_setter] = lambda do |pks|
-            if pks.empty?
-              send(opts.remove_all_method)
-            else
-              checked_transaction do
-                if clpk
-                  lpkv = lpk.map{|k| get_column_value(k)}
-                  cond = lk.zip(lpkv)
-                else
-                  lpkv = get_column_value(lpk)
-                  cond = {lk=>lpkv}
+          if !opts[:read_only] && !join_associated_table
+            opts[:pks_setter] = lambda do |pks|
+              if pks.empty?
+                send(opts.remove_all_method)
+              else
+                checked_transaction do
+                  if clpk
+                    lpkv = lpk.map{|k| get_column_value(k)}
+                    cond = lk.zip(lpkv)
+                  else
+                    lpkv = get_column_value(lpk)
+                    cond = {lk=>lpkv}
+                  end
+                  ds = _join_table_dataset(opts).where(cond)
+                  ds.exclude(rk=>pks).delete
+                  pks -= ds.select_map(rk)
+                  lpkv = Array(lpkv)
+                  key_array = crk ? pks.map{|pk| lpkv + pk} : pks.map{|pk| lpkv + [pk]}
+                  key_columns = Array(lk) + Array(rk)
+                  ds.import(key_columns, key_array)
                 end
-                ds = _join_table_dataset(opts).where(cond)
-                ds.exclude(rk=>pks).delete
-                pks -= ds.select_map(rk)
-                lpkv = Array(lpkv)
-                key_array = crk ? pks.map{|pk| lpkv + pk} : pks.map{|pk| lpkv + [pk]}
-                key_columns = Array(lk) + Array(rk)
-                ds.import(key_columns, key_array)
               end
             end
           end
@@ -124,29 +149,31 @@ module Sequel
             send(opts.dataset_method).select_map(opts.associated_class.primary_key)
           end
 
-          opts[:pks_setter] = lambda do |pks|
-            if pks.empty?
-              send(opts.remove_all_method)
-            else
-              primary_key = opts.associated_class.primary_key
-              pkh = {primary_key=>pks}
-
-              if key.is_a?(Array)
-                h = {}
-                nh = {}
-                key.zip(pk).each do|k, v|
-                  h[k] = v
-                  nh[k] = nil
-                end
+          unless opts[:read_only]
+            opts[:pks_setter] = lambda do |pks|
+              if pks.empty?
+                send(opts.remove_all_method)
               else
-                h = {key=>pk}
-                nh = {key=>nil}
-              end
+                primary_key = opts.associated_class.primary_key
+                pkh = {primary_key=>pks}
 
-              checked_transaction do
-                ds = send(opts.dataset_method)
-                ds.unfiltered.where(pkh).update(h)
-                ds.exclude(pkh).update(nh)
+                if key.is_a?(Array)
+                  h = {}
+                  nh = {}
+                  key.zip(pk).each do|k, v|
+                    h[k] = v
+                    nh[k] = nil
+                  end
+                else
+                  h = {key=>pk}
+                  nh = {key=>nil}
+                end
+
+                checked_transaction do
+                  ds = send(opts.dataset_method)
+                  ds.unfiltered.where(pkh).update(h)
+                  ds.exclude(pkh).update(nh)
+                end
               end
             end
           end
@@ -208,7 +235,7 @@ module Sequel
           pks = convert_pk_array(opts, pks)
 
           delay = opts.fetch(:delay_pks) do
-            Sequel::Deprecation.deprecate("association_pks will default to assuming the :delay_pks=>:always association option starting in Sequel 5.  Explicitly set :delay_pks=>false option for the association if you want changes to take effect immediately instead of being delayed until the object is saved (association: #{opts.inspect}).")
+            Sequel::Deprecation.deprecate("association_pks will default to assuming the :delay_pks=>:always association option starting in Sequel 5.  Explicitly set :delay_pks=>false option for the association if you want changes to take effect immediately instead of being delayed until the object is saved (association: #{opts.inspect})")
             false
           end
           if (new? && delay) || (delay == :always)
@@ -216,7 +243,7 @@ module Sequel
             (@_association_pks ||= {})[opts[:name]] = pks
           else
             if !new? && delay && delay != :always
-              Sequel::Deprecation.deprecate("association_pks with the :delay_pks=>true association option will also delay setting of associated values for existing objects in Sequel 5 (currently it just delays setting of associated values for new objects).  Please change to using :delay_pks=>:always to avoid this message.  Sequel 5 will not support the existing :delay_pks=>true behavior for only delaying for new objects and not for existing objects.")
+              Sequel::Deprecation.deprecate("association_pks with the :delay_pks=>true association option will also delay setting of associated values for existing objects in Sequel 5 (currently it just delays setting of associated values for new objects).  Please change to using :delay_pks=>:always to avoid this message.  Sequel 5 will not support the existing :delay_pks=>true behavior for only delaying for new objects and not for existing objects")
             end
             instance_exec(pks, &opts[:pks_setter])
           end

data/lib/sequel/plugins/association_proxies.rb

@@ -101,7 +101,7 @@ module Sequel
         def def_association_method(opts)
           if opts.returns_array?
             association_module_def(opts.association_method, opts) do |*dynamic_opts, &block|
-              Sequel::Deprecation.deprecate("Passing multiple arguments to ##{opts.association_method}", "Additional arguments are currently ignored.") if dynamic_opts.length > 1
+              Sequel::Deprecation.deprecate("Passing multiple arguments to ##{opts.association_method}", "Additional arguments are currently ignored") if dynamic_opts.length > 1
               AssociationProxy.new(self, opts, dynamic_opts.length == 0 ? OPTS : dynamic_opts[0], &block)
             end
           else

data/lib/sequel/plugins/auto_validations.rb

@@ -140,9 +140,13 @@ module Sequel
         # Skip automatic validations for the given validation type (:not_null, :types, :unique).
         # If :all is given as the type, skip all auto validations.
         def skip_auto_validations(type)
-          if type == :all
+          case type
+          when :all
             [:not_null, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
-          elsif type == :types
+          when :not_null
+            auto_validate_not_null_columns.clear
+            auto_validate_explicit_not_null_columns.clear
+          when :types
             @auto_validate_types = false
           else
             send("auto_validate_#{type}_columns").clear

data/lib/sequel/plugins/boolean_readers.rb

@@ -48,7 +48,7 @@ module Sequel
 
         # Add attribute? methods for all of the boolean attributes for this model.
         def create_boolean_readers
-          im = instance_methods.collect(&:to_s)
+          im = instance_methods.map(&:to_s)
           if cs = check_non_connection_error(false){columns}
             cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
           end

data/lib/sequel/plugins/caching.rb

@@ -19,8 +19,13 @@ module Sequel
     # raise an exception for a missing record, so if you use memcached, you will
     # want to use this option.
     #
-    # Note that only Model.[] method calls with a primary key argument are cached
-    # using this plugin.
+    # Note that only lookups by primary key are cached using this plugin.  The following
+    # methods use a lookup by primary key:
+    #
+    # * Model.with_pk
+    # * Model.with_pk!
+    # * Model.[] # when argument is not hash or nil
+    # * many_to_one association method # without dynamic callback, when primary key matches
     # 
     # Usage:
     #
@@ -68,7 +73,7 @@ module Sequel
 
         # Returns the prefix used to namespace this class in the cache.
         def cache_key_prefix
-          "#{self}"
+          to_s
         end
 
         # Return a key string for the given primary key.
@@ -86,26 +91,27 @@ module Sequel
         
         private
     
-        # Delete the entry with the matching key from the cache
-        def cache_delete(ck)
+        # Access the cache using the given method and key, rescuing exceptions if necessary.
+        def cache_op(meth, ck)
           if @cache_ignore_exceptions
-            @cache_store.delete(ck) rescue nil
+            @cache_store.send(meth, ck) rescue nil
           else
-            @cache_store.delete(ck)
+            @cache_store.send(meth, ck)
           end
+        end
+    
+        # Delete the entry with the matching key from the cache
+        def cache_delete(ck)
+          cache_op(:delete, ck)
           nil
         end
         
         # Returned the cached object, or nil if the object was not
         # in the cached
         def cache_get(ck)
-          if @cache_ignore_exceptions
-            @cache_store.get(ck) rescue nil
-          else
-            @cache_store.get(ck)
-          end
+          cache_op(:get, ck)
         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)

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -203,7 +203,7 @@ module Sequel
           @cti_instance_dataset = @instance_dataset
           @cti_table_columns = columns
           @cti_table_map = opts[:table_map] || {}
-          @cti_alias = opts[:alias]
+          @cti_alias = opts[:alias] # || table_name # SEQUEL5
         end
       end
 
@@ -216,6 +216,7 @@ module Sequel
         # This is the only model in the hierarchy that loads the
         # class_table_inheritance plugin. For backwards compatibility.
         def cti_base_model
+          Sequel::Deprecation.deprecate("#{self}.cti_base_model", "Use #{self}.cti_models.first instead")
           @cti_models.first
         end
 
@@ -228,12 +229,12 @@ module Sequel
         attr_reader :cti_instance_dataset
 
         # 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 for the base model, 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
+        # Specified with the :table_map option to the plugin, and should be used if
         # the implicit naming is incorrect.
         attr_reader :cti_table_map
 
@@ -247,10 +248,16 @@ module Sequel
         end
 
         # Alias to sti_key, for backwards compatibility.
-        def cti_key; sti_key; end
+        def cti_key
+          Sequel::Deprecation.deprecate("#{self}.cti_key", "Use #{self}.sti_key instead")
+          sti_key
+        end
 
         # Alias to sti_model_map, for backwards compatibility.
-        def cti_model_map; sti_model_map; end
+        def cti_model_map
+          Sequel::Deprecation.deprecate("#{self}.cti_model_map", "Use #{self}.sti_model_map instead")
+          sti_model_map
+        end
 
         # Freeze CTI information when freezing model class.
         def freeze
@@ -297,19 +304,20 @@ module Sequel
             cols = columns - [pk]
             dup_cols = cols & ds.columns
             unless dup_cols.empty?
+              # raise Error, "class_table_inheritance with duplicate column names (other than the primary key column) is not supported, make sure tables have unique column names"
               Sequel::Deprecation.deprecate("Using class_table_inheritance with duplicate column names (#{n} => #{dup_cols}) in subclass tables (other than the primary key column)', 'Make sure all tables used have unique column names, or implement support for handling duplicate column names in the class_table_inheritance plugin")
             end
             sel_app = cols.map{|cc| Sequel.qualify(table, Sequel.identifier(cc))}
             @sti_dataset = ds = ds.join(table, pk=>pk).select_append(*sel_app)
 
-            if @cti_alias
+            if @cti_alias # SEQUEL5: remove if
               ds = ds.from_self(:alias=>@cti_alias)
             end
 
             set_dataset(ds)
             set_columns(self.columns)
             @dataset = @dataset.with_row_proc(lambda{|r| subclass.sti_load(r)})
-            cols.each{|a| define_lazy_attribute_getter(a, :dataset=>dataset, :table=>@cti_alias||table)}
+            cols.each{|a| define_lazy_attribute_getter(a, :dataset=>dataset, :table=>@cti_alias||table)} # SEQUEL5: remove ||table
 
             @cti_models += [self]
             @cti_tables += [table]
@@ -325,7 +333,7 @@ module Sequel
         # The table name for the current model class's main table.
         def table_name
           if cti_tables
-            if @cti_alias
+            if @cti_alias # SEQUEL5: remove if
               @cti_alias
             else
               cti_tables.last
@@ -340,6 +348,7 @@ module Sequel
           cti_tables ? cti_tables.last : dataset.first_source_alias
         end
 
+        # The model class for the given key value.
         def sti_class_from_key(key)
           sti_class(sti_model_map[key])
         end
@@ -350,7 +359,7 @@ module Sequel
         # when setting subclass dataset.
         def sti_subclass_dataset(key)
           ds = super
-          if @cti_alias
+          if @cti_alias && cti_models[0] != self # SEQUEL5: remove @cti_alias
             ds = ds.from_self(:alias=>@cti_alias)
           end
           ds
@@ -395,7 +404,7 @@ module Sequel
         # Insert rows into all backing tables, using the columns
         # in each table.
         def _insert
-          return super if model.cti_tables.length == 1
+          return super if model.cti_models[0] == model
           model.cti_models.each do |m|
             v = {}
             m.cti_table_columns.each{|c| v[c] = @values[c] if @values.include?(c)}

data/lib/sequel/plugins/column_conflicts.rb

@@ -29,11 +29,16 @@ module Sequel
     #   # Make the Album class handle column conflicts automatically
     #   Album.plugin :column_conflicts
     module ColumnConflicts
-      # Check for column conflicts on the current model if the model has a dataset.
-      def self.configure(model)
+      def self.apply(model)
         model.instance_eval do
           @get_column_conflicts = {}
           @set_column_conflicts = {}
+        end
+      end
+
+      # Check for column conflicts on the current model if the model has a dataset.
+      def self.configure(model)
+        model.instance_eval do
           check_column_conflicts if @dataset
         end
       end

data/lib/sequel/plugins/column_select.rb

@@ -41,7 +41,7 @@ module Sequel
         # qualifying them with table's name.
         def convert_input_dataset(ds)
           ds = super
-          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join]
+          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join] # SEQUE5: just !ds.opts[:select]
             if db.supports_schema_parsing?
               cols = check_non_connection_error(false){db.schema(ds)}
               if cols

data/lib/sequel/plugins/csv_serializer.rb

@@ -76,9 +76,9 @@ module Sequel
 
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values
-      def self.configure(model, opts = {})
+      def self.configure(model, opts = OPTS)
         model.instance_eval do
-          @csv_serializer_opts = (@csv_serializer_opts || {}).merge(opts)
+          @csv_serializer_opts = (@csv_serializer_opts || OPTS).merge(opts)
         end
       end
 
@@ -87,7 +87,7 @@ module Sequel
         attr_reader :csv_serializer_opts
 
         # Attempt to parse an array of instances from the given CSV string
-        def array_from_csv(csv, opts = {})
+        def array_from_csv(csv, opts = OPTS)
           CSV.parse(csv, process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
@@ -105,13 +105,13 @@ module Sequel
         end
 
         # Attempt to parse a single instance from the given CSV string
-        def from_csv(csv, opts = {})
+        def from_csv(csv, opts = OPTS)
           new.from_csv(csv, opts)
         end
 
         # Convert the options hash to one that can be passed to CSV.
         def process_csv_serializer_opts(opts)
-          opts = (csv_serializer_opts || {}).merge(opts)
+          opts = (csv_serializer_opts || OPTS).merge(opts)
           opts_cols = opts.delete(:columns)
           opts_include = opts.delete(:include)
           opts_except = opts.delete(:except)
@@ -136,7 +136,7 @@ module Sequel
         #
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
-        def from_csv(csv, opts = {})
+        def from_csv(csv, opts = OPTS)
           row = CSV.parse_line(csv, model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
@@ -151,7 +151,7 @@ module Sequel
         #          output, ignoring all other columns
         # :include :: Symbol or Array of Symbols specifying non-column
         #             attributes to include in the CSV output.
-        def to_csv(opts = {})
+        def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts(opts)
 
           CSV.generate(opts) do |csv|
@@ -168,7 +168,7 @@ module Sequel
         #
         # :array :: An array of instances.  If this is not provided, calls #all
         #           on the receiver to get the array.
-        def to_csv(opts = {})
+        def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts({:columns=>columns}.merge!(opts))
           items = opts.delete(:array) || self