sequel 4.46.0 → 4.49.0

data/lib/sequel/extensions/string_agg.rb

@@ -53,7 +53,6 @@
 # * DB2 9.7+ (except distinct)
 # * MySQL
 # * HSQLDB
-# * CUBRID
 # * H2
 #
 # Related module: Sequel::SQL::StringAgg

data/lib/sequel/extensions/symbol_aref.rb

@@ -18,10 +18,6 @@
 # If you are using Ruby 2+, and you would like to use refinements, there
 # is a refinement version of this in the symbol_aref_refinement extension.
 #
-# If you are using the ruby18_symbol_extensions, and would like symbol_aref
-# to take affect, load the symbol_aref extension after the
-# ruby18_symbol_extensions.
-#
 # Related module: Sequel::SymbolAref
 
 if RUBY_VERSION >= '2.0'

data/lib/sequel/model/associations.rb

@@ -15,6 +15,7 @@ module Sequel
           @autoreloading_associations = {}
           @cache_associations = true
           @default_association_options = {}
+          @default_association_type_options = {}
           @dataset_module_class = DatasetModule
         end
       end
@@ -326,6 +327,7 @@ module Sequel
 
         # Alias of predicate_key, only for backwards compatibility.
         def eager_loading_predicate_key
+          Sequel::Deprecation.deprecate("AssociationReflection#eager_loading_predicate_key", "Use #predicate_key instead")
           predicate_key
         end
 
@@ -1449,7 +1451,7 @@ module Sequel
     
       # This module contains methods added to all association datasets
       module AssociationDatasetMethods
-        Dataset.def_deprecated_opts_setter(self, :model, :association_reflection)
+        Dataset.def_deprecated_opts_setter(self, :model_object, :association_reflection)
 
         # The model object that created the association dataset
         def model_object
@@ -1460,6 +1462,12 @@ module Sequel
         def association_reflection
           @opts[:association_reflection]
         end
+        
+        private
+
+        def non_sql_option?(key)
+          super || key == :model_object || key == :association_reflection
+        end
       end
       
       # Each kind of association adds a number of instance methods to the model class which
@@ -1526,9 +1534,15 @@ module Sequel
         # the previous class.
         attr_accessor :cache_associations
 
-        # The default options to use for all associations.
+        # The default options to use for all associations.  This hash is merged into the association reflection hash for
+        # all association reflections.
         attr_accessor :default_association_options
 
+        # The default options to use for all associations of a given type.  This is a hash keyed by association type
+        # symbol.  If there is a value for the association type symbol key, the resulting hash will be merged into the
+        # association reflection hash for all association reflections of that type.
+        attr_accessor :default_association_type_options
+
         # The default :eager_limit_strategy option to use for limited or offset associations (default: true, causing Sequel
         # to use what it considers the most appropriate strategy).
         attr_accessor :default_eager_limit_strategy
@@ -1768,7 +1782,13 @@ module Sequel
             orig_opts = cloned_assoc[:orig_opts].merge(orig_opts)
           end
 
-          opts = default_association_options.merge(orig_opts).merge(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
+          opts = Hash[default_association_options]
+          if type_options = default_association_type_options[type]
+            opts.merge!(type_options)
+          end
+          opts.merge!(orig_opts)
+          opts.merge!(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
+
           opts[:block] = block if block
           if !opts.has_key?(:instance_specific) && (block || orig_opts[:block] || orig_opts[:dataset])
             # It's possible the association is instance specific, in that it depends on
@@ -1784,6 +1804,7 @@ module Sequel
 
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
           if !opts.has_key?(:predicate_key) && opts.has_key?(:eager_loading_predicate_key)
+            Sequel::Deprecation.deprecate("The :eager_loading_predicate_key association option", "Use the :predicate_key option instead")
             opts[:predicate_key] = opts[:eager_loading_predicate_key]
           end
           opts[:graph_join_type] ||= :left_outer
@@ -1832,6 +1853,8 @@ module Sequel
           @association_reflections.freeze.each_value(&:freeze)
           @autoreloading_associations.freeze.each_value(&:freeze)
           @default_association_options.freeze
+          @default_association_type_options.freeze
+          @default_association_type_options.each_value(&:freeze)
 
           super
         end
@@ -1869,7 +1892,7 @@ module Sequel
           associate(:one_to_one, name, opts, &block)
         end
 
-        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_association_options=>:dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
+        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_association_options=>:dup, :@default_association_type_options=>:hash_dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
         Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
         private
@@ -1896,7 +1919,7 @@ module Sequel
         # Adds the association method to the association methods module.
         def def_association_method(opts)
           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
             load_associated_objects(opts, dynamic_opts.length == 0 ? OPTS : dynamic_opts[0], &block)
           end
         end
@@ -2534,6 +2557,7 @@ module Sequel
             end
 
             if res == false and stop_on_false
+              Sequel::Deprecation.deprecate("Having #{callback_type} association callback return false to cancel modification", "Instead, call Model#cancel_action inside the association callback")
               raise(HookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false")
             end
           end
@@ -2799,7 +2823,7 @@ END
 
         # If the dataset is being eagerly loaded, default to calling all
         # instead of each.
-        def to_hash(key_column=nil, value_column=nil, opts=OPTS)
+        def as_hash(key_column=nil, value_column=nil, opts=OPTS)
           if (@opts[:eager_graph] || @opts[:eager]) && !opts.has_key?(:all)
             opts = Hash[opts]
             opts[:all] = true
@@ -3024,7 +3048,7 @@ END
           #  specific foreign/primary key
           key_hash = {}
           # Reflections for all associations to eager load
-          reflections = eager_assoc.keys.collect{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
+          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
       
           # Populate the key_hash entry for each association being eagerly loaded
           reflections.each do |r|
@@ -3120,6 +3144,10 @@ END
         end
         alias one_to_one_association_filter_expression one_to_many_association_filter_expression
 
+        def non_sql_option?(key)
+          super || key == :eager || key == :eager_graph
+        end
+
         # Build associations from the graph if #eager_graph was used, 
         # and/or load other associations if #eager was used.
         def post_load(all_records)

data/lib/sequel/model/base.rb

@@ -7,16 +7,27 @@ module Sequel
 
     # Class methods for Sequel::Model that implement basic model functionality.
     #
-    # * All of the method names in Model::DATASET_METHODS have class methods created that call
-    #   the Model's dataset with the method of the same name with the given arguments.
+    # * All of the following methods have class methods created that send the method
+    #   to the model's dataset: all, as_hash, avg, count, cross_join, distinct, each,
+    #   each_server, empty?, except, exclude, exclude_having, fetch_rows,
+    #   filter, first, first!, for_update, from, from_self, full_join, full_outer_join,
+    #   get, graph, grep, group, group_and_count, group_append, group_by, having, import,
+    #   inner_join, insert, intersect, invert, join, join_table, last, left_join,
+    #   left_outer_join, limit, lock_style, map, max, min, multi_insert, naked, natural_full_join,
+    #   natural_join, natural_left_join, natural_right_join, offset, order, order_append, order_by,
+    #   order_more, order_prepend, paged_each, qualify, reverse, reverse_order, right_join,
+    #   right_outer_join, select, select_all, select_append, select_group, select_hash,
+    #   select_hash_groups, select_map, select_more, select_order_map, server,
+    #   single_record, single_record!, single_value, single_value!, sum, to_hash, to_hash_groups,
+    #   truncate, unfiltered, ungraphed, ungrouped, union, unlimited, unordered, where, where_all,
+    #   where_each, where_single_value, with, with_recursive, with_sql
     module ClassMethods
       # Which columns should be the only columns allowed in a call to a mass assignment method (e.g. set)
       # (default: not set, so all columns not otherwise restricted are allowed).
       attr_reader :allowed_columns # SEQUEL5: Deprecate after release
 
-      # Whether to cache the anonymous models created by Sequel::Model().  This is
-      # required for reloading them correctly (avoiding the superclass mismatch).  True
-      # by default for backwards compatibility.
+      # Whether to cache the anonymous models created by Sequel::Model(), true by default.  This is
+      # required for reloading them correctly (avoiding the superclass mismatch).
       attr_accessor :cache_anonymous_models
 
       # Array of modules that extend this model's dataset.  Stored
@@ -215,16 +226,20 @@ module Sequel
       end
   
       def initialize_copy(_)
-        Sequel::Deprecation.deprecate("Model.clone", "Create a subclass of the model instead of cloning it.")
+        Sequel::Deprecation.deprecate("Model.clone", "Create a subclass of the model instead of cloning it")
         # raise(Error, "cannot dup/clone a Sequel::Model class") # SEQUEL5
         super
       end
       def dup
-        Sequel::Deprecation.deprecate("Model.dup", "Create a subclass of the model instead of duping it.")
+        Sequel::Deprecation.deprecate("Model.dup", "Create a subclass of the model instead of duping it")
         # raise(Error, "cannot dup/clone a Sequel::Model class") # SEQUEL5
         super
       end
 
+      def <<(arg)
+        Sequel::Deprecation.deprecate("Sequel::Model.<<", "Switch to using #insert")
+        dataset << (arg)
+      end
 
       # Returns the first record from the database matching the conditions.
       # If a hash is given, it is used as the conditions.  If another
@@ -661,7 +676,7 @@ module Sequel
       #   end
       def inherited(subclass)
         super
-        ivs = subclass.instance_variables.collect(&:to_s)
+        ivs = subclass.instance_variables.map(&:to_s)
         inherited_instance_variables.each do |iv, dup|
           next if ivs.include?(iv.to_s)
           if (sup_class_value = instance_variable_get(iv)) && dup
@@ -700,14 +715,14 @@ module Sequel
         pluralize(underscore(demodulize(name))).to_sym
       end
   
-      # Calls #call with the values hash.  Only for backwards compatibility.
+      # Calls #call with the values hash.
       def load(values)
         call(values)
       end
 
       # Clear the setter_methods cache when a setter method is added
       def method_added(meth)
-        clear_setter_methods_cache if meth.to_s =~ SETTER_METHOD_REGEXP
+        clear_setter_methods_cache if meth.to_s.end_with?('=')
         super
       end
   
@@ -976,18 +991,26 @@ module Sequel
       end
   
       # Add model methods that call dataset methods
-      Plugins.def_dataset_methods(self, DATASET_METHODS)
+      Plugins.def_dataset_methods(self, (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server]) - [:<<, :and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases])
+      # SEQUEL5: add :set_graph_aliases to remove list and remove :and
   
       private
       
       # Yield to the passed block and swallow all errors other than DatabaseConnectionErrors.
-      def check_non_connection_error
+      def check_non_connection_error(do_raise=require_valid_table)
         begin
           db.transaction(:savepoint=>:only){yield}
         rescue Sequel::DatabaseConnectionError
           raise
         rescue Sequel::Error
-          raise if require_valid_table
+          case do_raise
+          when nil
+            Sequel::Deprecation.deprecate("Setting a model class dataset to an invalid dataset", "Either use a valid dataset or set require_valid_table = false for the model class")
+          when false
+            # nothing
+          else
+            raise
+          end
         end
       end
 
@@ -1000,6 +1023,7 @@ module Sequel
           ds = db.from(ds)
         when Dataset
           if ds.joined_dataset?
+            # raise Error, "Using a joined dataset as a model dataset is not support, use from_self on the dataset to wrap it in a subquery" # SEQUEL5
             Sequel::Deprecation.deprecate("Using a joined dataset as a Sequel::Model dataset", respond_to?(:cti_base_model) ? "Use the class_table_inheritance plugin :alias option in #{cti_base_model.inspect}" : "Call from_self on the dataset to wrap it in a subquery")
           end
 
@@ -1038,9 +1062,9 @@ module Sequel
       # use a string to define the method for speed.  For other columns names, use a block.
       def def_column_accessor(*columns)
         clear_setter_methods_cache
-        columns, bad_columns = columns.partition{|x| NORMAL_METHOD_NAME_REGEXP.match(x.to_s)}
+        columns, bad_columns = columns.partition{|x| /\A[A-Za-z_][A-Za-z0-9_]*\z/.match(x.to_s)}
         bad_columns.each{|x| def_bad_column_accessor(x)}
-        im = instance_methods.collect(&:to_s)
+        im = instance_methods.map(&:to_s)
         columns.each do |column|
           meth = "#{column}="
           overridable_methods_module.module_eval("def #{column}; self[:#{column}] end", __FILE__, __LINE__) unless im.include?(column.to_s)
@@ -1054,7 +1078,7 @@ module Sequel
       def def_model_dataset_method(meth)
         return if respond_to?(meth, true)
 
-        if meth.to_s =~ NORMAL_METHOD_NAME_REGEXP
+        if meth.to_s =~ /\A[A-Za-z_][A-Za-z0-9_]*\z/
           instance_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
         else
           (class << self; self; end).send(:define_method, meth){|*args, &block| dataset.send(meth, *args, &block)}
@@ -1097,14 +1121,14 @@ module Sequel
         schema_hash = {}
         ds_opts = dataset.opts
         get_columns = proc{check_non_connection_error{columns} || []}
-        schema_array = check_non_connection_error{db.schema(dataset, :reload=>reload)} if db.supports_schema_parsing?
+        schema_array = check_non_connection_error(false){db.schema(dataset, :reload=>reload)} if db.supports_schema_parsing?
         if schema_array
           schema_array.each{|k,v| schema_hash[k] = v}
 
           # Set the primary key(s) based on the schema information,
           # if the schema information includes primary key information
           if schema_array.all?{|k,v| v.has_key?(:primary_key)}
-            pks = schema_array.collect{|k,v| k if v[:primary_key]}.compact
+            pks = schema_array.map{|k,v| k if v[:primary_key]}.compact
             pks.length > 0 ? set_primary_key(pks) : no_primary_key
           end
 
@@ -1119,7 +1143,7 @@ module Sequel
             # Dataset is for a single table with all columns,
             # so set the columns based on the order they were
             # returned by the schema.
-            cols = schema_array.collect{|k,v| k}
+            cols = schema_array.map{|k,v| k}
             set_columns(cols)
             # Also set the columns for the dataset, so the dataset
             # doesn't have to do a query to get them.
@@ -1141,18 +1165,46 @@ module Sequel
           # SEQUEL5: Remove allowed_columns handling
           allowed_columns.map{|x| "#{x}="}
         else
-          meths = instance_methods.collect(&:to_s).grep(SETTER_METHOD_REGEXP) - RESTRICTED_SETTER_METHODS
+          meths = instance_methods.map(&:to_s).select{|l| l.end_with?('=')} - RESTRICTED_SETTER_METHODS
           meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && restrict_primary_key?
           meths
         end
       end
   
       # A hash of instance variables to automatically set up in subclasses.
-      # See Sequel::Model::INHERITED_INSTANCE_VARIABLES.  It is safe to modify
-      # the hash returned by this method, though it may not be safe to modify
-      # values of the hash.
+      # Keys are instance variable symbols, values should be:
+      # nil :: Assign directly from superclass to subclass (frozen objects)
+      # :dup :: Dup object when assigning from superclass to subclass (mutable objects)
+      # :hash_dup :: Assign hash with same keys, but dup all the values
+      # Proc :: Call with subclass to do the assignment
       def inherited_instance_variables
-        INHERITED_INSTANCE_VARIABLES.dup
+        {
+          :@allowed_columns=>:dup, # SEQUEL5: Remove
+          :@cache_anonymous_models=>nil,
+          :@dataset_method_modules=>:dup,
+          :@dataset_module_class=>nil,
+          :@db=>nil,
+          :@default_set_fields_options=>:dup,
+          :@fast_instance_delete_sql=>nil,
+          :@fast_pk_lookup_sql=>nil,
+          :@finder_loaders=>:dup, # SEQUEL5: Remove
+          :@finders=>:dup, # SEQUEL5: Remove
+          :@plugins=>:dup,
+          :@primary_key=>nil,
+          :@raise_on_save_failure=>nil,
+          :@raise_on_typecast_failure=>nil,
+          :@require_modification=>nil,
+          :@require_valid_table=>nil,
+          :@restrict_primary_key=>nil,
+          :@setter_methods=>nil,
+          :@simple_pk=>nil,
+          :@simple_table=>nil,
+          :@strict_param_setting=>nil,
+          :@typecast_empty_string_to_nil=>nil,
+          :@typecast_on_assignment=>nil,
+          :@use_after_commit_rollback=>nil,
+          :@use_transactions=>nil
+        }
       end
     
       # For the given opts hash and default name or :class option, add a
@@ -1196,6 +1248,7 @@ module Sequel
           rescue LoadError => e
             begin
               require "sequel_#{plugin}"
+              Sequel::Deprecation.deprecate("requiring 'sequel_#{plugin}' to load a plugin", "Update the #{plugin} plugin to be required via 'sequel/plugins/#{plugin}'")
             rescue LoadError => e2
               e.message << "; #{e2.message}"
               raise e
@@ -1249,6 +1302,7 @@ module Sequel
           ds.fetch_rows(sql){|r| return ds.row_proc.call(r)}
           nil
         elsif dataset.joined_dataset?
+          # SEQUEL5: Remove as joined model datasets are not allowed
           dataset.first(qualified_primary_key_hash(pk))
         else
           dataset.first(primary_key_hash(pk))
@@ -1311,19 +1365,21 @@ module Sequel
 
     # Sequel::Model instance methods that implement basic model functionality.
     #
-    # * All of the methods in +HOOKS+ and +AROUND_HOOKS+ create instance methods that are called
+    # * All of the model before/after/around hooks are implemented as instance methods that are called
     #   by Sequel when the appropriate action occurs.  For example, when destroying
     #   a model object, Sequel will call +around_destroy+, which will call +before_destroy+, do
     #   the destroy, and then call +after_destroy+.
     # * The following instance_methods all call the class method of the same
     #   name: columns, db, primary_key, db_schema.
-    # * All of the methods in +BOOLEAN_SETTINGS+ create attr_writers allowing you
-    #   to set values for the attribute.  It also creates instance getters returning
-    #   the value of the setting.  If the value has not yet been set, it
-    #   gets the default value from the class by calling the class method of the same name.
+    # * The following accessor methods are defined via metaprogramming:
+    #   raise_on_save_failure, raise_on_typecast_failure, require_modification,
+    #   strict_param_setting, typecast_empty_string_to_nil, typecast_on_assignment,
+    #   and use_transactions.  The setter methods will change the setting for the
+    #   instance, and the getter methods will check for an instance setting, then
+    #   try the class setting if no instance setting has been set.
     module InstanceMethods
       HOOKS.each{|h| class_eval("def #{h}; end", __FILE__, __LINE__)}
-      AROUND_HOOKS.each{|h| class_eval("def #{h}; yield end", __FILE__, __LINE__)}
+      [:around_create, :around_update, :around_save, :around_destroy, :around_validation].each{|h| class_eval("def #{h}; yield end", __FILE__, __LINE__)}
 
       # Define instance method(s) that calls class method(s) of the
       # same name. Replaces the construct:
@@ -1334,8 +1390,13 @@ module Sequel
       # Define instance method(s) that calls class method(s) of the
       # same name, caching the result in an instance variable.  Define
       # standard attr_writer method for modifying that instance variable.
-      BOOLEAN_SETTINGS.each{|meth| class_eval("def #{meth}; !defined?(@#{meth}) ? (frozen? ? self.class.#{meth} : (@#{meth} = self.class.#{meth})) : @#{meth} end", __FILE__, __LINE__)}
-      attr_writer(*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
+      ].each do |meth|
+        class_eval("def #{meth}; !defined?(@#{meth}) ? (frozen? ? self.class.#{meth} : (@#{meth} = self.class.#{meth})) : @#{meth} end", __FILE__, __LINE__)
+        attr_writer(meth)
+      end
 
       # The hash of attribute values.  Keys are symbols with the names of the
       # underlying database columns. The returned hash is a reference to the
@@ -1882,7 +1943,7 @@ module Sequel
 
       # Clear the setter_methods cache when a method is added
       def singleton_method_added(meth)
-        @singleton_setter_added = true if meth.to_s =~ SETTER_METHOD_REGEXP
+        @singleton_setter_added = true if meth.to_s.end_with?('=')
         super
       end
   
@@ -1895,6 +1956,7 @@ module Sequel
         raise Error, "No dataset for model #{model}" unless ds = model.instance_dataset
 
         cond = if ds.joined_dataset?
+          # SEQUEL5: Remove as joined model datasets are now allowed
           qualified_pk_hash
         else
           pk_hash
@@ -2136,7 +2198,7 @@ module Sequel
         sh = {:server=>this_server}
         uacr = use_after_commit_rollback
         if uacr.nil? ? (method(:after_rollback).owner != InstanceMethods) : uacr
-          Sequel::Deprecation.deprecate("Model#after_rollback", "Instead, call db.after_rollback in Model#before_save.")
+          Sequel::Deprecation.deprecate("Model#after_rollback", "Instead, call db.after_rollback in Model#before_save")
           db.after_rollback(sh){after_rollback}
         end
         pk = nil
@@ -2203,7 +2265,7 @@ module Sequel
         raise_hook_failure(:around_save) unless called_save
         _after_save(pk) # SEQUEL5: Remove
         if uacr.nil? ? (method(:after_commit).owner != InstanceMethods) : uacr
-          Sequel::Deprecation.deprecate("Model#after_commit", "Instead, call db.after_commit in Model#after_save.")
+          Sequel::Deprecation.deprecate("Model#after_commit", "Instead, call db.after_commit in Model#after_save")
           db.after_commit(sh){after_commit}
         end
         self
@@ -2436,7 +2498,7 @@ module Sequel
         if type.is_a?(Array)
           type.map{|x| "#{x}="}
         else
-          meths = methods.collect(&:to_s).grep(SETTER_METHOD_REGEXP) - RESTRICTED_SETTER_METHODS
+          meths = methods.map(&:to_s).select{|l| l.end_with?('=')} - RESTRICTED_SETTER_METHODS
           meths -= Array(primary_key).map{|x| "#{x}="} if type != :all && primary_key && model.restrict_primary_key?
           meths
         end
@@ -2600,15 +2662,15 @@ module Sequel
         end
       end
 
-      # This allows you to call +to_hash+ without any arguments, which will
+      # This allows you to call +as_hash+ without any arguments, which will
       # result in a hash with the primary key value being the key and the
       # model object being the value.
       #
-      #   Artist.dataset.to_hash # SELECT * FROM artists
+      #   Artist.dataset.as_hash # SELECT * FROM artists
       #   # => {1=>#<Artist {:id=>1, ...}>,
       #   #     2=>#<Artist {:id=>2, ...}>,
       #   #     ...}
-      def to_hash(key_column=nil, value_column=nil, opts=OPTS)
+      def as_hash(key_column=nil, value_column=nil, opts=OPTS)
         if key_column
           super
         else
@@ -2617,50 +2679,9 @@ module Sequel
         end
       end
 
-      # Return an array of all rows matching the given filter condition, also
-      # yielding each row to the given block.  Basically the same as where(cond).all(&block),
-      # except it can be optimized to not create an intermediate dataset.
-      #
-      #   Artist.where_all(:id=>[1,2,3])
-      #   # SELECT * FROM artists WHERE (id IN (1, 2, 3))
-      def where_all(cond, &block)
-        if loader = _model_where_loader
-          loader.all(filter_expr(cond), &block)
-        else
-          where(cond).all(&block)
-        end
-      end
-
-      # Iterate over all rows matching the given filter condition, 
-      # yielding each row to the given block.  Basically the same as where(cond).each(&block),
-      # except it can be optimized to not create an intermediate dataset.
-      #
-      #   Artist.where_each(:id=>[1,2,3]){|row| p row}
-      #   # SELECT * FROM artists WHERE (id IN (1, 2, 3))
-      def where_each(cond, &block)
-        if loader = _model_where_loader
-          loader.each(filter_expr(cond), &block)
-        else
-          where(cond).each(&block)
-        end
-      end
-
-      # Filter the datasets using the given filter condition, then return a single value.
-      # This assumes that the dataset has already been setup to limit the selection to
-      # a single column.  Basically the same as where(cond).single_value,
-      # except it can be optimized to not create an intermediate dataset.
-      #
-      #   Artist.select(:name).where_single_value(:id=>1)
-      #   # SELECT name FROM artists WHERE (id = 1) LIMIT 1
-      def where_single_value(cond)
-        if loader = cached_placeholder_literalizer(:_model_where_single_value_loader) do |pl|
-            single_value_ds.where(pl.arg)
-          end
-
-          loader.get(filter_expr(cond))
-        else
-          where(cond).single_value
-        end
+      # Alias of as_hash for backwards compatibility.
+      def to_hash(*a)
+        as_hash(*a)
       end
 
       # Given a primary key value, return the first record in the dataset with that primary key
@@ -2689,11 +2710,12 @@ module Sequel
 
       private
 
-      # Loader used for where_all and where_each.
+      # SEQUEL5: Remove
       def _model_where_loader
-        cached_placeholder_literalizer(:_model_where_loader) do |pl|
-          where(pl.arg)
-        end
+        # :nocov:
+        Sequel::Deprecation.deprecate("Dataset#_model_where_loader", "Use _where_loader instead")
+        _where_loader
+        # :nocov:
       end
 
       # If the dataset is not already ordered, and the model has a primary key,
@@ -2720,6 +2742,10 @@ module Sequel
           where(cond).limit(1)
         end
       end
+
+      def non_sql_option?(key)
+        super || key == :model
+      end
     end
 
     extend ClassMethods

data/lib/sequel/model/dataset_module.rb

@@ -3,12 +3,11 @@
 module Sequel
   class Model
     # This Module subclass is used by Model.dataset_module
-    # to add dataset methods to classes.  It adds a couple
-    # of features standard Modules, allowing you to use
-    # the same subset method you can call on Model, as well
-    # as making sure that public methods added to the module
-    # automatically have class methods created for them.
-    class DatasetModule < ::Module
+    # to add dataset methods to classes.  In addition to the
+    # methods offered by Dataset::DatasetModule, it also
+    # automatically creates class methods for public dataset
+    # methods.
+    class DatasetModule < Dataset::DatasetModule
       # Store the model related to this dataset module.
       def initialize(model)
         @model = model
@@ -19,43 +18,6 @@ module Sequel
         where(name, *args, &block)
       end
 
-      %w'where exclude exclude_having having'.map(&:to_sym).each do |meth|
-        define_method(meth) do |name, *args, &block|
-          if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
-            define_method(name){send(meth, *args, &block)}
-          else
-            key = :"_#{meth}_#{name}_ds"
-            define_method(name) do
-              cached_dataset(key){send(meth, *args)}
-            end
-          end
-        end
-      end
-
-      meths = (<<-METHS).split.map(&:to_sym)
-        distinct grep group group_and_count group_append 
-        limit offset order order_append order_prepend 
-        select select_all select_append select_group server
-      METHS
-
-      # Define a method in the module
-      def self.def_dataset_caching_method(mod, meth)
-        mod.send(:define_method, meth) do |name, *args, &block|
-          if block
-            define_method(name){send(meth, *args, &block)}
-          else
-            key = :"_#{meth}_#{name}_ds"
-            define_method(name) do
-              cached_dataset(key){send(meth, *args)}
-            end
-          end
-        end
-      end
-
-      meths.each do |meth|
-        def_dataset_caching_method(self, meth)
-      end
-
       private
 
       # Add a class method to the related model that

data/lib/sequel/model/errors.rb

@@ -6,6 +6,7 @@ module Sequel
     # with a few convenience methods.
     class Errors < ::Hash
       ATTRIBUTE_JOINER = ' and '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :ATTRIBUTE_JOINER)
 
       # Adds an error for the given attribute.
       #
@@ -40,7 +41,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(' and ')} #{e}")}
           m
         end
       end