sequel 4.46.0 → 4.49.0

data/lib/sequel/model/inflections.rb

@@ -26,17 +26,29 @@ module Sequel
   # already have been loaded.
   module Inflections
     CAMELIZE_CONVERT_REGEXP = /(^|_)(.)/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :CAMELIZE_CONVERT_REGEXP)
     CAMELIZE_MODULE_REGEXP = /\/(.?)/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :CAMELIZE_MODULE_REGEXP)
     DASH = '-'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :DASH)
     DEMODULIZE_CONVERT_REGEXP = /^.*::/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :DEMODULIZE_CONVERT_REGEXP)
     EMPTY_STRING= ''.freeze
+    Sequel::Deprecation.deprecate_constant(self, :EMPTY_STRING)
     SLASH = '/'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :SLASH)
     VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :VALID_CONSTANT_NAME_REGEXP)
     UNDERSCORE = '_'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE)
     UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)([A-Z][a-z])/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REGEXP1)
     UNDERSCORE_CONVERT_REGEXP2 = /([a-z\d])([A-Z])/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REGEXP2)
     UNDERSCORE_CONVERT_REPLACE = '\1_\2'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REPLACE)
     UNDERSCORE_MODULE_REGEXP = /::/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_MODULE_REGEXP)
 
     @plurals, @singulars, @uncountables = [], [], []
 
@@ -113,7 +125,7 @@ module Sequel
     def camelize(s)
       s = s.to_s
       return s.camelize if s.respond_to?(:camelize)
-      s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase}
+      s = s.gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
       s
     end
   
@@ -123,7 +135,7 @@ module Sequel
     def constantize(s)
       s = s.to_s
       return s.constantize if s.respond_to?(:constantize)
-      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s)
+      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(s)
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
   
@@ -131,7 +143,7 @@ module Sequel
     def demodulize(s)
       s = s.to_s
       return s.demodulize if s.respond_to?(:demodulize)
-      s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
+      s.gsub(/^.*::/, '')
     end
   
     # Returns the plural form of the word in the string.
@@ -157,8 +169,8 @@ module Sequel
     def underscore(s)
       s = s.to_s
       return s.underscore if s.respond_to?(:underscore)
-      s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE).
-        gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase
+      s.gsub('::', '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
     end
   end
 end

data/lib/sequel/model.rb

@@ -31,62 +31,36 @@ module Sequel
   class Model
     OPTS = Sequel::OPTS
 
-    # Class methods added to model that call the method of the same name on the dataset
-    DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server, :where_all, :where_each, :where_single_value]) -
-      [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases] # SEQUEL5: Remove set_graph_aliases
-    
-    # Boolean settings that can be modified at the global, class, or instance level.
-    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, \
-      :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions,
-      :use_after_commit_rollback # SEQUEL5: Remove
-      ]
-
-    # Hooks that are called before an action.  Can return false to not do the action.  When
-    # overriding these, it is recommended to call +super+ as the last line of your method,
-    # so later hooks are called before earlier hooks.
+    DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server, :where_all, :where_each, :where_single_value]) - [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases]
+    Sequel::Deprecation.deprecate_constant(self, :DATASET_METHODS)
+    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions, :use_after_commit_rollback]
+    Sequel::Deprecation.deprecate_constant(self, :BOOLEAN_SETTINGS)
     BEFORE_HOOKS = [:before_create, :before_update, :before_save, :before_destroy, :before_validation]
-
-    # Hooks that are called after an action.  When overriding these, it is recommended to call
-    # +super+ on the first line of your method, so later hooks are called after earlier hooks.
-    AFTER_HOOKS = [:after_create, :after_update, :after_save, :after_destroy, :after_validation,
-    :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback] # SEQUEL5: Remove commit/rollback hooks
-
-    # Hooks that are called around an action.  If overridden, these methods must call super
-    # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions
-    # raised by the code they wrap or ensure that some behavior is executed no matter what.
+    Sequel::Deprecation.deprecate_constant(self, :BEFORE_HOOKS)
+    AFTER_HOOKS = [:after_create, :after_update, :after_save, :after_destroy, :after_validation, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]
+    Sequel::Deprecation.deprecate_constant(self, :AFTER_HOOKS)
     AROUND_HOOKS = [:around_create, :around_update, :around_save, :around_destroy, :around_validation]
+    Sequel::Deprecation.deprecate_constant(self, :AROUND_HOOKS)
+    NORMAL_METHOD_NAME_REGEXP = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+    Sequel::Deprecation.deprecate_constant(self, :NORMAL_METHOD_NAME_REGEXP)
+    SETTER_METHOD_REGEXP = /=\z/
+    Sequel::Deprecation.deprecate_constant(self, :SETTER_METHOD_REGEXP)
+    ANONYMOUS_MODEL_CLASSES = @Model_cache = {}
+    Sequel::Deprecation.deprecate_constant(self, :ANONYMOUS_MODEL_CLASSES)
+    ANONYMOUS_MODEL_CLASSES_MUTEX = Mutex.new
+    Sequel::Deprecation.deprecate_constant(self, :ANONYMOUS_MODEL_CLASSES_MUTEX)
+    INHERITED_INSTANCE_VARIABLES = { :@allowed_columns=>:dup, :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil, :@raise_on_save_failure=>nil, :@require_modification=>nil, :@restrict_primary_key=>nil, :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil, :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil, :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil, :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil, :@fast_instance_delete_sql=>nil, :@finders=>:dup, :@finder_loaders=>:dup, :@db=>nil, :@default_set_fields_options=>:dup, :@require_valid_table=>nil, :@cache_anonymous_models=>nil, :@dataset_module_class=>nil}
+    Sequel::Deprecation.deprecate_constant(self, :INHERITED_INSTANCE_VARIABLES)
 
     # Empty instance methods to create that the user can override to get hook/callback behavior.
     # Just like any other method defined by Sequel, if you override one of these, you should
     # call +super+ to get the default behavior (while empty by default, they can also be defined
     # by plugins).  See the {"Model Hooks" guide}[rdoc-ref:doc/model_hooks.rdoc] for
     # more detail on hooks.
-    HOOKS = BEFORE_HOOKS + AFTER_HOOKS
-
-    # Class instance variables that are inherited in subclasses.  If the value is <tt>:dup</tt>, dup is called
-    # on the superclass's instance variable when creating the instance variable in the subclass.
-    # If the value is +nil+, the superclass's instance variable is used directly in the subclass.
-    INHERITED_INSTANCE_VARIABLES = {
-      :@allowed_columns=>:dup, # SEQUEL5: Remove
-      :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil,
-      :@raise_on_save_failure=>nil, :@require_modification=>nil, :@restrict_primary_key=>nil,
-      :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
-      :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
-      :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
-      :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil,
-      :@fast_instance_delete_sql=>nil,
-      :@finders=>:dup, :@finder_loaders=>:dup, # SEQUEL5: Remove
-      :@db=>nil, :@default_set_fields_options=>:dup, :@require_valid_table=>nil,
-      :@cache_anonymous_models=>nil, :@dataset_module_class=>nil}
-
-    # Regular expression that determines if a method name is normal in the sense that
-    # it could be used literally in ruby code without using send.  Used to
-    # avoid problems when using eval with a string to define methods.
-    NORMAL_METHOD_NAME_REGEXP = /\A[A-Za-z_][A-Za-z0-9_]*\z/
-
-    # Regular expression that determines if the method is a valid setter name
-    # (i.e. it ends with =).
-    SETTER_METHOD_REGEXP = /=\z/
+    HOOKS = [:before_create, :before_update, :before_save, :before_destroy, :before_validation,
+      :after_create, :after_update, :after_save, :after_destroy, :after_validation,
+      :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback # SEQUEL5: Remove commit/rollback hooks
+    ]#.freeze # SEQUEL5
 
     @allowed_columns = nil # SEQUEL5: Remove
     @cache_anonymous_models = true
@@ -106,7 +80,7 @@ module Sequel
     @raise_on_save_failure = true
     @raise_on_typecast_failure = false
     @require_modification = nil
-    @require_valid_table = false
+    @require_valid_table = nil
     @restrict_primary_key = true
     @setter_methods = nil
     @simple_pk = nil
@@ -123,11 +97,11 @@ module Sequel
       plugin Model::Associations
     end
 
+    def_Model(::Sequel)
+
     # The setter methods (methods ending with =) that are never allowed
     # to be called automatically via +set+/+update+/+new+/etc..
-    RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).grep(SETTER_METHOD_REGEXP)
-
-    def_Model(::Sequel)
+    RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).select{|l| l.end_with?('=')}#.freeze # SEQUEL5
 
     # SEQUEL5: Remove
     class DeprecatedColumnsUpdated # :nodoc:
@@ -140,11 +114,5 @@ module Sequel
         @columns_updated.send(*args, &block)
       end
     end
-      
-    ANONYMOUS_MODEL_CLASSES = @Model_cache # :nodoc:
-    Sequel::Deprecation.deprecate_constant(self, :ANONYMOUS_MODEL_CLASSES)
-
-    ANONYMOUS_MODEL_CLASSES_MUTEX = Mutex.new # :nodoc:
-    Sequel::Deprecation.deprecate_constant(self, :ANONYMOUS_MODEL_CLASSES_MUTEX)
   end
 end

data/lib/sequel/plugins/active_model.rb

@@ -18,8 +18,8 @@ module Sequel
     #   # Make the Album class active_model compliant
     #   Album.plugin :active_model
     module ActiveModel
-      # The default string to join composite primary keys with in to_param.
       DEFAULT_TO_PARAM_JOINER = '-'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_TO_PARAM_JOINER)
       
       # ActiveModel compliant error class
       class Errors < Sequel::Model::Errors
@@ -119,7 +119,7 @@ module Sequel
         
         # The string to use to join composite primary key param strings.
         def to_param_joiner
-          DEFAULT_TO_PARAM_JOINER
+          '-'
         end
       end
     end

data/lib/sequel/plugins/association_autoreloading.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The association_autoreloading plugin", "This plugin was integrated into the default model behavior in Sequel 4.0, and no longer has an effect")
+
 module Sequel
   module Plugins
     # Empty plugin module for backwards compatibility

data/lib/sequel/plugins/association_dependencies.rb

@@ -6,9 +6,9 @@ module Sequel
     # 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, one_to_one - :delete, :destroy, :nullify (sets foreign key to NULL for all associated objects)
+    # :many_to_many :: :nullify (removes all related entries in join table)
+    # :many_to_one :: :delete, :destroy
+    # :one_to_many, one_to_one :: :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.

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,8 +48,8 @@ module Sequel
 
         # Add attribute? methods for all of the boolean attributes for this model.
         def create_boolean_readers
-          im = instance_methods.collect(&:to_s)
-          if cs = check_non_connection_error{columns}
+          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
         end

data/lib/sequel/plugins/boolean_subsets.rb

@@ -48,7 +48,7 @@ module Sequel
 
         # Add subset methods for all of the boolean columns in this model.
         def create_boolean_subsets
-          if cs = check_non_connection_error{columns}
+          if cs = check_non_connection_error(false){columns}
             cs = cs.select{|c| db_schema[c][:type] == :boolean}.map{|c| boolean_subset_args(c)}
             dataset_module do
               cs.each{|c| where(*c)}

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
 
@@ -241,16 +242,23 @@ module Sequel
         # giving the columns to update in each backing database table.
         # For backwards compatibility.
         def cti_columns
+          Sequel::Deprecation.deprecate("#{self}.cti_columns", "Use #{self}.cti_models to get the models, cti_table_name to get the name for the model, and cti_table_columns to get the columns for the model")
           h = {}
           cti_models.each { |m| h[m.cti_table_name] = m.cti_table_columns }
           h
         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
@@ -281,7 +289,7 @@ module Sequel
               columns = db.from(table).columns
             else
               table = subclass.implicit_table_name
-              columns = check_non_connection_error{db.from(table).columns}
+              columns = check_non_connection_error(false){db.from(table).columns}
               table = nil if !columns || columns.empty?
             end
           end
@@ -295,20 +303,22 @@ module Sequel
               ds = ds.select(*self.columns.map{|cc| Sequel.qualify(cti_table_name, Sequel.identifier(cc))})
             end
             cols = columns - [pk]
-            unless (cols & ds.columns).empty?
-              Sequel::Deprecation.deprecate('Using class_table_inheritance with duplicate column names 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')
+            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]
@@ -324,7 +334,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
@@ -339,6 +349,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
@@ -349,7 +360,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
@@ -394,7 +405,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)}