sequel 4.47.0 → 4.48.0

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -23,6 +23,8 @@
 #
 # Related module: Sequel::Sequel3DatasetMethods
 
+Sequel::Deprecation.deprecate("The sequel_3_dataset_methods extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
+
 #
 module Sequel
   module Sequel3DatasetMethods
@@ -122,7 +124,7 @@ module Sequel
       cols = n.columns
       csv = String.new
       csv << "#{cols.join(', ')}\r\n" if include_column_titles
-      n.each{|r| csv << "#{cols.collect{|c| r[c]}.join(', ')}\r\n"}
+      n.each{|r| csv << "#{cols.map{|c| r[c]}.join(', ')}\r\n"}
       csv
     end
   end

data/lib/sequel/extensions/sequel_4_dataset_methods.rb

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+#
+# This adds the following dataset methods:
+#
+# and :: alias for where
+# exclude_where :: alias for exclude
+# interval :: Returns max - min, using a single query
+# range :: Returns min..max, using a single query
+#
+# It is only recommended to use this for backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:sequel_4_dataset_methods)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:sequel_4_dataset_methods)
+#
+# Related module: Sequel::Sequel4DatasetMethods
+
+#
+module Sequel
+  module Sequel4DatasetMethods
+    # Alias for where.
+    def and(*cond, &block)
+      where(*cond, &block)
+    end
+    
+    # Alias for exclude.
+    def exclude_where(*cond, &block)
+      exclude(*cond, &block)
+    end
+
+    # Returns the interval between minimum and maximum values for the given 
+    # column/expression. Uses a virtual row block if no argument is given.
+    #
+    #   DB[:table].interval(:id) # SELECT (max(id) - min(id)) FROM table LIMIT 1
+    #   # => 6
+    #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
+    #   # => 7
+    def interval(column=Sequel.virtual_row(&Proc.new))
+      if loader = cached_placeholder_literalizer(:_interval_loader) do |pl|
+          arg = pl.arg
+          aggregate_dataset.limit(1).select((SQL::Function.new(:max, arg) - SQL::Function.new(:min, arg)).as(:interval))
+        end
+
+        loader.get(column)
+      else
+        aggregate_dataset.get{(max(column) - min(column)).as(:interval)}
+      end
+    end
+
+    # Returns a +Range+ instance made from the minimum and maximum values for the
+    # given column/expression.  Uses a virtual row block if no argument is given.
+    #
+    #   DB[:table].range(:id) # SELECT max(id) AS v1, min(id) AS v2 FROM table LIMIT 1
+    #   # => 1..10
+    #   DB[:table].interval{function(column)} # SELECT max(function(column)) AS v1, min(function(column)) AS v2 FROM table LIMIT 1
+    #   # => 0..7
+    def range(column=Sequel.virtual_row(&Proc.new))
+      r = if loader = cached_placeholder_literalizer(:_range_loader) do |pl|
+            arg = pl.arg
+            aggregate_dataset.limit(1).select(SQL::Function.new(:min, arg).as(:v1), SQL::Function.new(:max, arg).as(:v2))
+          end
+
+        loader.first(column)
+      else
+        aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
+      end
+
+      if r
+        (r[:v1]..r[:v2])
+      end
+    end
+    
+  end
+
+  Dataset.register_extension(:sequel_4_dataset_methods, Sequel4DatasetMethods)
+end
+

data/lib/sequel/extensions/set_overrides.rb

@@ -73,8 +73,8 @@ module Sequel
     end
 
     # Dataset options that do not affect the generated SQL.
-    def non_sql_options
-      super + [:defaults, :overrides]
+    def non_sql_option?(key)
+      super || key == :defaults || key == :overrides
     end
   end
 

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.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
@@ -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/model/associations.rb

@@ -1450,7 +1450,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
@@ -1461,6 +1461,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
@@ -1782,7 +1788,6 @@ module Sequel
           opts.merge!(orig_opts)
           opts.merge!(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
 
-          opts
           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
@@ -1912,7 +1917,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
@@ -2815,7 +2820,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
@@ -3040,7 +3045,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|
@@ -3136,6 +3141,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,8 +7,20 @@ 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).
@@ -215,16 +227,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 +677,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
@@ -707,7 +723,7 @@ module Sequel
 
       # 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,7 +992,8 @@ 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, :where_all, :where_each, :where_single_value]) - [:<<, :and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases])
+      # SEQUEL5: add :set_graph_aliases to remove list and remove :and
   
       private
       
@@ -1007,6 +1024,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
 
@@ -1045,9 +1063,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)
@@ -1061,7 +1079,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)}
@@ -1111,7 +1129,7 @@ module Sequel
           # 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
 
@@ -1126,7 +1144,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.
@@ -1148,18 +1166,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
@@ -1256,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))
@@ -1318,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:
@@ -1341,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
@@ -1889,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
   
@@ -1902,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
@@ -2143,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
@@ -2210,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
@@ -2443,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
@@ -2607,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
@@ -2624,6 +2679,11 @@ module Sequel
         end
       end
 
+      # Alias of as_hash for backwards compatibility.
+      def to_hash(*a)
+        as_hash(*a)
+      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.
@@ -2727,6 +2787,10 @@ module Sequel
           where(cond).limit(1)
         end
       end
+
+      def non_sql_option?(key)
+        super || key == :model
+      end
     end
 
     extend ClassMethods