sequel 3.47.0 → 3.48.0

data/lib/sequel/extensions/set_overrides.rb

@@ -0,0 +1,43 @@
+# The set_overrides extension adds the Dataset#set_overrides and
+# Dataset#set_defaults methods which provide a crude way to
+# control the values used in INSERT/UPDATE statements if a hash
+# of values is passed to Dataset#insert or Dataset#update.
+# It is only recommended to use this for backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds.extension(:set_overrides)
+#
+# 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(:set_overrides)
+
+module Sequel
+  module SetOverrides
+    Dataset.def_mutation_method(:set_defaults, :set_overrides, :module=>self)
+
+    # Set the default values for insert and update statements.  The values hash passed
+    # to insert or update are merged into this hash, so any values in the hash passed
+    # to insert or update will override values passed to this method.  
+    #
+    #   DB[:items].set_defaults(:a=>'a', :c=>'c').insert(:a=>'d', :b=>'b')
+    #   # INSERT INTO items (a, c, b) VALUES ('d', 'c', 'b')
+    def set_defaults(hash)
+      clone(:defaults=>(@opts[:defaults]||{}).merge(hash))
+    end
+
+    # Set values that override hash arguments given to insert and update statements.
+    # This hash is merged into the hash provided to insert or update, so values
+    # will override any values given in the insert/update hashes.
+    #
+    #   DB[:items].set_overrides(:a=>'a', :c=>'c').insert(:a=>'d', :b=>'b')
+    #   # INSERT INTO items (a, c, b) VALUES ('a', 'c', 'b')
+    def set_overrides(hash)
+      clone(:overrides=>hash.merge(@opts[:overrides]||{}))
+    end
+  end
+
+  Dataset.register_extension(:set_overrides, SetOverrides)
+end

data/lib/sequel/extensions/to_dot.rb

@@ -9,6 +9,9 @@
 
 module Sequel
   class ToDot
+    module DatasetMethods
+    end
+
     # The option keys that should be included in the dot output.
     TO_DOT_OPTIONS = [:with, :distinct, :select, :from, :join, :where, :group, :having, :compounds, :order, :limit, :offset, :lock].freeze
 
@@ -147,7 +150,10 @@ module Sequel
     # with graphviz) in order to see a visualization of the dataset's
     # abstract syntax tree.
     def to_dot
+      Sequel::Deprecation.deprecate('Loading the to_dot extension globally', "Please use Database/Dataset#extension to load the extension into this dataset") unless is_a?(ToDot::DatasetMethods)
       ToDot.output(self)
     end
   end
+
+  Dataset.register_extension(:to_dot, ToDot::DatasetMethods)
 end

data/lib/sequel/model.rb

@@ -35,7 +35,7 @@ module Sequel
   #     dataset # => DB1[:comments]
   #   end
   def self.Model(source)
-    if Sequel::Model.cache_anonymous_models && (klass = Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
+    if cache_anonymous_models && (klass = Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
       return klass
     end
     klass = if source.is_a?(Database)
@@ -45,10 +45,19 @@ module Sequel
     else
       Class.new(Model).set_dataset(source)
     end
-    Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if Sequel::Model.cache_anonymous_models
+    Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if cache_anonymous_models
     klass
   end
 
+  @cache_anonymous_models = true
+
+  class << self
+    # 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.
+    attr_accessor :cache_anonymous_models
+  end
+
   # <tt>Sequel::Model</tt> is an object relational mapper built on top of Sequel core.  Each
   # model class is backed by a dataset instance, and many dataset methods can be
   # called directly on the class.  Model datasets return rows as model instances,
@@ -63,16 +72,13 @@ module Sequel
   # You can set the +SEQUEL_NO_ASSOCIATIONS+ constant or environment variable to
   # make Sequel not load the associations plugin by default.
   class Model
-    # Cache anonymous models created by Sequel::Model()
-    @cache_anonymous_models = true
-
     # Map that stores model classes created with <tt>Sequel::Model()</tt>, to allow the reopening
     # of classes when dealing with code reloading.
     ANONYMOUS_MODEL_CLASSES = {}
 
     # 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_page, :each_server, :print, :destroy, :with_pk, :with_pk!]) - [:and, :or, :[], :[]=, :columns, :columns!]
+      [:each_server]) - [:and, :or, :[], :[]=, :columns, :columns!, :delete, :update, :add_graph_aliases]
     
     # Class instance variables to set to nil when a subclass is created, for -w compliance
     EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@db]

data/lib/sequel/model/associations.rb

@@ -188,20 +188,32 @@ module Sequel
         # it sets album.artist to this_artist.
         def reciprocal
           cached_fetch(:reciprocal) do
-            r_types = Array(reciprocal_type)
-            keys = self[:keys]
-            recip = nil
+            possible_recips = []
+            fallback_recips = []
+
             associated_class.all_association_reflections.each do |assoc_reflect|
-              if r_types.include?(assoc_reflect[:type]) && assoc_reflect[:keys] == keys && assoc_reflect.associated_class == self[:model]
-                cached_set(:reciprocal_type, assoc_reflect[:type])
-                recip = assoc_reflect[:name]
-                break
+              if reciprocal_association?(assoc_reflect)
+                if deprecated_reciprocal_association?(assoc_reflect)
+                  fallback_recips << assoc_reflect
+                else
+                  possible_recips << assoc_reflect
+                end
               end
             end
-            recip
+
+            Sequel::Deprecation.deprecate("Multiple reciprocal association candidates found for #{self[:name]} association (#{possible_recips.map{|r| r[:name]}.join(', ')}).  Choosing the first candidate is", "Please explicitly specify the reciprocal option for the #{self[:name]} association") if possible_recips.size >= 2
+            if possible_recips.empty? && !fallback_recips.empty?
+              possible_recips = fallback_recips
+              Sequel::Deprecation.deprecate("All reciprocal association candidates found for #{self[:name]} association have conditions, blocks, or differing primary keys (#{possible_recips.map{|r| r[:name]}.join(', ')}).  Automatic choosing of an reciprocal association with conditions or blocks is", "Please explicitly specify the reciprocal option for the #{self[:name]} association")
+            end
+
+            unless possible_recips.empty?
+              cached_set(:reciprocal_type, possible_recips.first[:type]) if reciprocal_type.is_a?(Array)
+              possible_recips.first[:name]
+            end
           end
         end
-    
+
         # Whether the reciprocal of this association returns an array of objects instead of a single object,
         # true by default.
         def reciprocal_array?
@@ -288,6 +300,16 @@ module Sequel
           end
         end
 
+        # REMOVE40: merge into reciprocal_association?
+        def deprecated_reciprocal_association?(assoc_reflect)
+          assoc_reflect[:conditions] || assoc_reflect[:block]
+        end
+
+        def reciprocal_association?(assoc_reflect)
+          Array(reciprocal_type).include?(assoc_reflect[:type]) &&
+            assoc_reflect.associated_class == self[:model]
+        end
+    
         # If +s+ is an array, map +s+ over the block.  Otherwise, just call the
         # block with +s+.
         def transform(s)
@@ -378,6 +400,15 @@ module Sequel
     
         private
     
+        # REMOVE40: merge into reciprocal_association?
+        def deprecated_reciprocal_association?(assoc_reflect)
+          super || primary_key != assoc_reflect.primary_key
+        end
+
+        def reciprocal_association?(assoc_reflect)
+          super && self[:keys] == assoc_reflect[:keys]
+        end
+
         # The reciprocal type of a many_to_one association is either
         # a one_to_many or a one_to_one association.
         def reciprocal_type
@@ -444,6 +475,15 @@ module Sequel
     
         private
     
+        # REMOVE40: merge into reciprocal_association?
+        def deprecated_reciprocal_association?(assoc_reflect)
+          super || primary_key != assoc_reflect.primary_key
+        end
+
+        def reciprocal_association?(assoc_reflect)
+          super && self[:keys] == assoc_reflect[:keys]
+        end
+
         # The reciprocal type of a one_to_many association is a many_to_one association.
         def reciprocal_type
           :many_to_one
@@ -570,25 +610,6 @@ module Sequel
           true
         end
     
-        # Returns the reciprocal association symbol, if one exists.
-        def reciprocal
-          cached_fetch(:reciprocal) do
-            left_keys = self[:left_keys]
-            right_keys = self[:right_keys]
-            join_table = self[:join_table]
-            recip = nil
-            associated_class.all_association_reflections.each do |assoc_reflect|
-              if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_keys] == right_keys &&
-                 assoc_reflect[:right_keys] == left_keys && assoc_reflect[:join_table] == join_table &&
-                 assoc_reflect.associated_class == self[:model]
-                recip = assoc_reflect[:name]
-                break
-              end
-            end
-            recip
-          end
-        end
-
         # #right_primary_key qualified by the associated table
         def qualified_right_primary_key
           cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
@@ -623,6 +644,21 @@ module Sequel
 
         private
 
+        # REMOVE40: merge into reciprocal_association?
+        def deprecated_reciprocal_association?(assoc_reflect)
+          super || right_primary_keys != assoc_reflect[:left_primary_key_columns] || self[:left_primary_key_columns] != assoc_reflect.right_primary_keys
+        end
+
+        def reciprocal_association?(assoc_reflect)
+          super && assoc_reflect[:left_keys] == self[:right_keys] &&
+            assoc_reflect[:right_keys] == self[:left_keys] &&
+            assoc_reflect[:join_table] == self[:join_table]
+        end
+
+        def reciprocal_type
+          :many_to_many
+        end
+
         # Split the join table into source and alias parts.
         def split_join_table_alias
           associated_class.dataset.split_alias(self[:join_table])
@@ -782,12 +818,10 @@ module Sequel
         # :eager_graph :: The associations to eagerly load via +eager_graph+ when loading the associated object(s).
         #                 many_to_many associations with this option cannot be eagerly loaded via +eager+.
         # :eager_grapher :: A proc to use to implement eager loading via +eager_graph+, overriding the default.
-        #                   Takes one or three arguments. If three arguments, they are a dataset, an alias to use for
-        #                   the table to graph for this association, and the alias that was used for the current table
-        #                   (since you can cascade associations). If one argument, is passed a hash with keys :self,
-        #                   :table_alias, and :implicit_qualifier, corresponding to the three arguments, and an optional
-        #                   additional key :eager_block, a callback accepting one argument, the associated dataset. This
-        #                   is used to customize the association at query time.
+        #                   Takes an options hash with the entries :self (the receiver of the eager_graph call),
+        #                   :table_alias (the alias to use for table to graph into the association), :implicit_qualifier
+        #                   (the alias that was used for the current table), and possibly :eager_block (a callback
+        #                   proc accepting the associated dataset, for per-call customization).
         #                   Should return a copy of the dataset with the association graphed into it.
         # :eager_limit_strategy :: Determines the strategy used for enforcing limits when eager loading associations via
         #                          the +eager+ method.  For one_to_one associations, no strategy is used by default, and
@@ -795,8 +829,8 @@ module Sequel
         #                          all records but slices the resulting array after the association is retrieved.  You
         #                          can pass a +true+ value for this option to have Sequel pick what it thinks is the best
         #                          choice for the database, or specify a specific symbol to manually select a strategy.
-        #                          one_to_one associations support :distinct_on, :window_function, and :correlated_subquery.
-        #                          *_many associations support :ruby, :window_function, and :correlated_subquery.
+        #                          one_to_one associations support :distinct_on and :window_function.
+        #                          *_many associations support :ruby, and :window_function.
         # :eager_loader :: A proc to use to implement eager loading, overriding the default.  Takes a single hash argument,
         #                  with at least the keys: :rows, which is an array of current model instances, :associations,
         #                  which is a hash of dependent associations, :self, which is the dataset doing the eager loading,
@@ -922,12 +956,18 @@ module Sequel
         #                              Defaults to :right_primary_key option.
         # :uniq :: Adds a after_load callback that makes the array of objects unique.
         def associate(type, name, opts = {}, &block)
-          raise(Error, 'one_to_many association type with :one_to_one option removed, used one_to_one association type') if opts[:one_to_one] && type == :one_to_many
+          if opts[:one_to_one] && type == :one_to_many
+            Sequel::Deprecation.deprecate('Raising an Error when the one_to_many type uses the :one_to_one option', "Use the one_to_one associationtype")
+            raise(Error, 'one_to_many association type with :one_to_one option removed, used one_to_one association type')
+          end
           raise(Error, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
-          raise(Error, 'Model.associate name argument must be a symbol') unless Symbol === name
+          raise(Error, 'Model.associate name argument must be a symbol') unless name.is_a?(Symbol)
           raise(Error, ':eager_loader option must have an arity of 1 or 3') if opts[:eager_loader] && ![1, 3].include?(opts[:eager_loader].arity)
           raise(Error, ':eager_grapher option must have an arity of 1 or 3') if opts[:eager_grapher] && ![1, 3].include?(opts[:eager_grapher].arity)
 
+          Sequel::Deprecation.deprecate('The :eager_loader association option accepting 3 arguments', "Please switch to accepting a single options hash") if opts[:eager_loader] && opts[:eager_loader].arity == 3
+          Sequel::Deprecation.deprecate('The :eager_grapher association option accepting 3 arguments', "Please switch to accepting a single options hash") if opts[:eager_grapher] && opts[:eager_grapher].arity == 3
+
           # dup early so we don't modify opts
           orig_opts = opts.dup
           if opts[:clone]
@@ -1023,6 +1063,7 @@ module Sequel
       
         # Use a correlated subquery to limit the results of the eager loading dataset.
         def apply_correlated_subquery_eager_limit_strategy(ds, opts)
+          Sequel::Deprecation.deprecate('The correlated_subquery eager limit strategy',  'Switch to another eager limit strategy.')
           klass = opts.associated_class
           kds = klass.dataset
           dsa = ds.send(:dataset_alias, 1)
@@ -1460,6 +1501,7 @@ module Sequel
         # Formally used internally by the associations code, like pk but doesn't raise
         # an Error if the model has no primary key.  Not used any longer, deprecated.
         def pk_or_nil
+          Sequel::Deprecation.deprecate('Model#pk_or_nil', 'There is no replacement')
           key = primary_key
           key.is_a?(Array) ? key.map{|k| @values[k]} : @values[key]
         end

data/lib/sequel/model/base.rb

@@ -12,10 +12,15 @@ module Sequel
       # (default: not set, so all columns not otherwise restricted are allowed).
       attr_reader :allowed_columns
 
-      # 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.
-      attr_accessor :cache_anonymous_models
+      # REMOVE40
+      def cache_anonymous_models
+        Sequel::Deprecation.deprecate('Model.cache_anonymous_models', 'Please switch to Sequel.cache_anonymous_models')
+        Sequel.cache_anonymous_models
+      end
+      def cache_anonymous_models=(v)
+        Sequel::Deprecation.deprecate('Model.cache_anonymous_models=', 'Please switch to Sequel.cache_anonymous_models=')
+        Sequel.cache_anonymous_models = v
+      end
   
       # Array of modules that extend this model's dataset.  Stored
       # so that if the model's dataset is changed, it will be extended
@@ -63,10 +68,14 @@ module Sequel
       # Sequel will not check the number of rows modified (default: true).
       attr_accessor :require_modification
   
-      # Which columns are specifically restricted in a call to set/update/new/etc.
-      # (default: not set).  Some columns are restricted regardless of
-      # this setting, such as the primary key column and columns in Model::RESTRICTED_SETTER_METHODS.
-      attr_reader :restricted_columns
+      # REMOVE40
+      def restricted_columns
+        Sequel::Deprecation.deprecate('Model.restricted_columns', 'Please load the blacklist_security plugin to continue using it')
+        @restricted_columns
+      end
+      def _restricted_columns
+        @restricted_columns
+      end
   
       # Should be the literal primary key column name if this Model's table has a simple primary key, or
       # nil if the model has a compound primary key or no primary key.
@@ -254,7 +263,7 @@ module Sequel
       # sharding support.
       def db=(db)
         @db = db
-        set_dataset(db.dataset(@dataset.opts)) if @dataset
+        set_dataset(db.dataset.clone(@dataset.opts)) if @dataset
       end
       
       # Returns the cached schema information if available or gets it
@@ -342,9 +351,11 @@ module Sequel
       # may contain setter methods.
       def include(mod)
         clear_setter_methods_cache
+        check_deprecated_after_initialize(mod.instance_methods) unless allowed_after_initialize_implementation?(mod)
+        Sequel::Deprecation.deprecate('Model#set_values', 'Please override Model.call, Model#_refresh_set_values, and/or Model#_create_set_values depending on the type of behavior you want to change') if mod.public_instance_methods.map{|x| x.to_s}.include?('set_values') && mod.name.to_s !~ /\ASequel::(Model|Model::Associations|Plugins::(ForceEncoding|Serialization|TypecastOnLoad|Composition|PreparedStatementsSafe|Dirty|PgTypecastOnLoad))::InstanceMethods\z/
         super
       end
-  
+
       # If possible, set the dataset for the model subclass as soon as it
       # is created.  Also, make sure the inherited class instance variables
       # are copied into the subclass.
@@ -405,6 +416,8 @@ 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
+        check_deprecated_after_initialize(meth)
+        Sequel::Deprecation.deprecate('Model#set_values', 'Please override Model.call, Model#_refresh_set_values, and/or Model#_create_set_values depending on the type of behavior you want to change') if meth.to_s == 'set_values'
         super
       end
   
@@ -431,7 +444,18 @@ module Sequel
           m.apply(self, *args, &block) if m.respond_to?(:apply)
           include(m::InstanceMethods) if plugin_module_defined?(m, :InstanceMethods)
           extend(m::ClassMethods)if plugin_module_defined?(m, :ClassMethods)
-          dataset_extend(m::DatasetMethods) if plugin_module_defined?(m, :DatasetMethods)
+          if plugin_module_defined?(m, :DatasetMethods)
+            dataset_extend(m::DatasetMethods, :create_class_methods=>false)
+            # REMOVE40
+            m::DatasetMethods.public_instance_methods.each do |meth|
+              unless respond_to?(meth, true)
+                (class << self; self; end).send(:define_method, meth) do |*args, &block|
+                  Sequel::Deprecation.deprecate('Automatically defining Model class methods for plugin public dataset methods', "Please modify the plugin to use Plugins.def_dataset_method for #{meth}")
+                  dataset.send(meth, *args, &block)
+                end
+              end
+            end
+          end
         end
         m.configure(self, *args, &block) if m.respond_to?(:configure)
       end
@@ -521,10 +545,10 @@ module Sequel
       # sharding support.
       def set_dataset(ds, opts={})
         inherited = opts[:inherited]
-        @dataset = case ds
+        case ds
         when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, LiteralString
           self.simple_table = db.literal(ds)
-          db.from(ds)
+          ds = db.from(ds)
         when Dataset
           self.simple_table = if ds.send(:simple_select_all?)
             ds.literal(ds.first_source_table)
@@ -532,11 +556,11 @@ module Sequel
             nil
           end
           @db = ds.db
-          ds
         else
           raise(Error, "Model.set_dataset takes one of the following classes as an argument: Symbol, LiteralString, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, Dataset")
         end
-        @dataset.row_proc = self
+        set_dataset_row_proc(ds)
+        @dataset = ds
         @require_modification = Sequel::Model.require_modification.nil? ? @dataset.provides_accurate_rows_matched? : Sequel::Model.require_modification
         if inherited
           self.simple_table = superclass.simple_table
@@ -565,6 +589,9 @@ module Sequel
       #     set_primary_key [:taggable_id, :tag_id]
       #   end
       def set_primary_key(*key)
+        Sequel::Deprecation.deprecate('Calling set_primary_key without arguments is deprecated and will raise an exception in Sequel 4. Please use no_primary_key to mark the model as not having a primary key.') if key.length == 0
+        Sequel::Deprecation.deprecate('Calling set_primary_key with multiple arguments is deprecated and will raise an exception in Sequel 4. Please pass an array of keys to setup a composite primary key.') if key.length > 1
+        
         clear_setter_methods_cache
         key = key.flatten
         self.simple_pk = if key.length == 1
@@ -590,6 +617,7 @@ module Sequel
       #   Artist.set(:name=>'Bob', :records_sold=>30000) # Error
       def set_restricted_columns(*cols)
         clear_setter_methods_cache
+        Sequel::Deprecation.deprecate('Model.set_restricted_columns', 'Please switch to Model.set_allowed_columns or use the blacklist_security plugin')
         @restricted_columns = cols
       end
 
@@ -600,7 +628,7 @@ module Sequel
         else
           meths = instance_methods.collect{|x| x.to_s}.grep(SETTER_METHOD_REGEXP) - RESTRICTED_SETTER_METHODS
           meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && restrict_primary_key?
-          meths -= restricted_columns.map{|x| "#{x}="} if restricted_columns
+          meths -= _restricted_columns.map{|x| "#{x}="} if _restricted_columns
           meths
         end
       end
@@ -651,6 +679,37 @@ module Sequel
         clear_setter_methods_cache
         @restrict_primary_key = false
       end
+
+      # Return the model instance with the primary key, or nil if there is no matching record.
+      def with_pk(pk)
+        primary_key_lookup(pk)
+      end
+
+      # Return the model instance with the primary key, or raise NoMatchingRow if there is no matching record.
+      def with_pk!(pk)
+        with_pk(pk) || raise(NoMatchingRow)
+      end
+  
+      # Add model methods that call dataset methods
+      Plugins.def_dataset_methods(self, DATASET_METHODS)
+
+      # REMOVE40
+      %w'print each_page set add_graph_aliases insert_multiple query set_overrides set_defaults to_csv paginate'.each do |meth|
+        class_eval(<<-END, __FILE__, __LINE__+1)
+          def #{meth}(*args, &block)
+            Sequel::Deprecation.deprecate('Model.#{meth}', 'Please use Model.dataset.#{meth} instead')
+            dataset.#{meth}(*args, &block)
+          end
+        END
+      end
+      %w'destroy delete update'.each do |meth|
+        class_eval(<<-END, __FILE__, __LINE__+1)
+          def #{meth}(*args, &block)
+            Sequel::Deprecation.deprecate('Model.#{meth}', 'Please use the scissors plugin or Model.dataset.#{meth} instead')
+            dataset.#{meth}(*args, &block)
+          end
+        END
+      end
   
       private
       
@@ -665,14 +724,28 @@ module Sequel
         end
       end
 
+      # REMOVE40
+      def allowed_after_initialize_implementation?(mod)
+        mod == InstanceMethods || mod.to_s == 'Sequel::Plugins::HookClassMethods::InstanceMethods'
+      end
+  
+      # REMOVE40
+      def check_deprecated_after_initialize(meths)
+        Array(meths).each do |meth|
+          Sequel::Deprecation.deprecate('The Model after_initialize hook', 'Please use the after_initialize plugin to continue using the hook') if meth.to_s == 'after_initialize'
+        end
+      end
+
       # Add the module to the class's dataset_method_modules.  Extend the dataset with the
       # module if the model has a dataset.  Add dataset methods to the class for all
       # public dataset methods.
-      def dataset_extend(mod)
-        @dataset.extend(mod) if defined?(@dataset) && @dataset
+      def dataset_extend(mod, opts={})
+        @dataset.extend(mod) if @dataset
         reset_instance_dataset
         dataset_method_modules << mod
-        mod.public_instance_methods.each{|meth| def_model_dataset_method(meth)}
+        unless opts[:create_class_methods] == false
+          mod.public_instance_methods.each{|meth| def_model_dataset_method(meth)}
+        end
       end
 
       # Create a column accessor for a column with a method name that is hard to use in ruby code.
@@ -719,7 +792,7 @@ 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)}
+        schema_array = check_non_connection_error{db.schema(dataset, :reload=>reload)} if db.supports_schema_parsing?
         if schema_array
           schema_array.each{|k,v| schema_hash[k] = v}
           if ds_opts.include?(:select)
@@ -739,7 +812,7 @@ module Sequel
             # 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.length > 0 ? set_primary_key(*pks) : no_primary_key
+              pks.length > 0 ? set_primary_key(pks) : no_primary_key
             end
             # Also set the columns for the dataset, so the dataset
             # doesn't have to do a query to get them.
@@ -780,7 +853,7 @@ module Sequel
       # Module that the class includes that holds methods the class adds for column accessors and
       # associations so that the methods can be overridden with +super+.
       def overridable_methods_module
-        include(@overridable_methods_module = Module.new) unless defined?(@overridable_methods_module) && @overridable_methods_module
+        include(@overridable_methods_module = Module.new) unless @overridable_methods_module
         @overridable_methods_module
       end
       
@@ -792,10 +865,10 @@ module Sequel
            (Sequel.const_defined?(module_name) &&
             Sequel::Plugins.const_get(module_name) == Sequel.const_get(module_name))
           begin
-            Sequel.tsk_require "sequel/plugins/#{plugin}"
+            require "sequel/plugins/#{plugin}"
           rescue LoadError => e
             begin
-              Sequel.tsk_require "sequel_#{plugin}"
+              require "sequel_#{plugin}"
             rescue LoadError => e2
               e.message << "; #{e2.message}"
               raise e
@@ -848,7 +921,7 @@ module Sequel
       # Reset the instance dataset to a modified copy of the current dataset,
       # should be used whenever the model's dataset is modified.
       def reset_instance_dataset
-        @instance_dataset = @dataset.limit(1).naked if defined?(@dataset) && @dataset
+        @instance_dataset = @dataset.limit(1).naked if @dataset
       end
   
       # Set the columns for this model and create accessor methods for each column.
@@ -858,6 +931,11 @@ module Sequel
         @columns
       end
 
+      # Set the dataset's row_proc to the current model.
+      def set_dataset_row_proc(ds)
+        ds.row_proc = self
+      end
+
       # Reset the fast primary key lookup SQL when the simple_pk value changes.
       def simple_pk=(pk)
         @simple_pk = pk
@@ -870,9 +948,6 @@ module Sequel
         reset_fast_pk_lookup_sql
       end
 
-      # Add model methods that call dataset methods
-      Plugins.def_dataset_methods(self, DATASET_METHODS)
-  
       # Returns a copy of the model's dataset with custom SQL
       #
       #   Artist.fetch("SELECT * FROM artists WHERE name LIKE 'A%'")
@@ -896,32 +971,29 @@ module Sequel
       HOOKS.each{|h| class_eval("def #{h}; end", __FILE__, __LINE__)}
       AROUND_HOOKS.each{|h| class_eval("def #{h}; yield end", __FILE__, __LINE__)}
 
-      # 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.
-      #
-      # Do not call this method with untrusted input, as that can result in
-      # arbitrary code execution.
+      # REMOVE40
       def self.class_attr_overridable(*meths) # :nodoc:
+        Sequel::Deprecation.deprecate('Model::InstanceMethods.class_attr_overridable', "There is no replacement planned")
         meths.each{|meth| class_eval("def #{meth}; !defined?(@#{meth}) ? (frozen? ? self.class.#{meth} : (@#{meth} = self.class.#{meth})) : @#{meth} end", __FILE__, __LINE__)}
         attr_writer(*meths) 
       end 
-    
-      # Define instance method(s) that calls class method(s) of the
-      # same name. Replaces the construct:
-      #   
-      #   define_method(meth){self.class.send(meth)}
-      #
-      # Do not call this method with untrusted input, as that can result in
-      # arbitrary code execution.
       def self.class_attr_reader(*meths) # :nodoc:
+        Sequel::Deprecation.deprecate('Model::InstanceMethods.class_attr_reader', "There is no replacement planned")
         meths.each{|meth| class_eval("def #{meth}; self.class.#{meth} end", __FILE__, __LINE__)}
       end
-
       private_class_method :class_attr_overridable, :class_attr_reader
 
-      class_attr_reader :columns, :db, :primary_key, :db_schema
-      class_attr_overridable(*BOOLEAN_SETTINGS)
+      # Define instance method(s) that calls class method(s) of the
+      # same name. Replaces the construct:
+      #   
+      #   define_method(meth){self.class.send(meth)}
+      [:columns, :db, :primary_key, :db_schema].each{|meth| class_eval("def #{meth}; self.class.#{meth} end", __FILE__, __LINE__)}
+
+      # 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)
 
       # The hash of attribute values.  Keys are symbols with the names of the
       # underlying database columns.
@@ -948,6 +1020,7 @@ module Sequel
       #   end
       def initialize(values = {}, from_db = false)
         if from_db
+          Sequel::Deprecation.deprecate('Passing two arguments to Model.new', 'Please use Model.call instead')
           set_values(values)
         else
           @values = {}
@@ -1074,7 +1147,7 @@ module Sequel
       # Returns the validation errors associated with this object.
       # See +Errors+.
       def errors
-        @errors ||= Errors.new
+        @errors ||= errors_class.new
       end 
 
       # Returns true when current instance exists, false otherwise.
@@ -1088,7 +1161,7 @@ module Sequel
       #   Artist.new.exists?
       #   # => false
       def exists?
-        new? ? false : !this.get(1).nil?
+        new? ? false : !this.get(SQL::AliasedExpression.new(1, :one)).nil?
       end
       
       # Ignore the model's setter method cache when this instances extends a module, as the
@@ -1292,6 +1365,7 @@ module Sequel
       # Takes the following options:
       #
       # :changed :: save all changed columns, instead of all columns or the columns given
+      # :columns :: array of specific columns that should be saved.
       # :raise_on_failure :: set to true or false to override the current
       #                      +raise_on_save_failure+ setting
       # :server :: set the server/shard on the object before saving, and use that
@@ -1302,6 +1376,10 @@ module Sequel
       def save(*columns)
         raise Sequel::Error, "can't save frozen object" if frozen?
         opts = columns.last.is_a?(Hash) ? columns.pop : {}
+
+        Sequel::Deprecation.deprecate('Passing columns as separate arguments to Model#save', 'Instead, provide a :columns option with the array of columns to save.') unless columns.empty?
+        columns.concat(Array(opts[:columns])) if opts[:columns]
+
         set_server(opts[:server]) if opts[:server] 
         if opts[:validate] != false
           unless checked_save_failure(opts){_valid?(true, opts)}
@@ -1337,9 +1415,9 @@ module Sequel
       end
   
       # Set all values using the entries in the hash, ignoring any setting of
-      # allowed_columns or restricted columns in the model.
+      # allowed_columns in the model.
       #
-      #   Artist.set_restricted_columns(:name)
+      #   Artist.set_allowed_columns(:num_albums)
       #   artist.set_all(:name=>'Jim')
       #   artist.name # => 'Jim'
       def set_all(hash)
@@ -1353,6 +1431,7 @@ module Sequel
       #   artist.set_except({:name=>'Jim'}, :hometown)
       #   artist.name # => 'Jim'
       def set_except(hash, *except)
+        Sequel::Deprecation.deprecate('Model#set_except', 'Please switch to Model#set_only or use the blacklist_security plugin')
         set_restricted(hash, false, except.flatten)
       end
   
@@ -1462,9 +1541,9 @@ module Sequel
       end
   
       # Update all values using the entries in the hash, ignoring any setting of
-      # +allowed_columns+ or +restricted_columns+ in the model.
+      # +allowed_columns+ in the model.
       #
-      #   Artist.set_restricted_columns(:name)
+      #   Artist.set_allowed_columns(:num_albums)
       #   artist.update_all(:name=>'Jim') # UPDATE artists SET name = 'Jim' WHERE (id = 1)
       def update_all(hash)
         update_restricted(hash, false, false)
@@ -1476,6 +1555,7 @@ module Sequel
       #
       #   artist.update_except({:name=>'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
       def update_except(hash, *except)
+        Sequel::Deprecation.deprecate('Model#update_except', 'Please switch to Model#update_only or use the blacklist_security plugin')
         update_restricted(hash, false, except.flatten)
       end
   
@@ -1789,6 +1869,11 @@ module Sequel
         @values[column] = value
       end
 
+      # Default error class used for errors.
+      def errors_class
+        Errors
+      end
+
       # Set the columns with the given hash.  By default, the same as +set+, but
       # exists so it can be overridden.  This is called only for new records, before
       # changed_columns is cleared.
@@ -1869,7 +1954,7 @@ module Sequel
       # well, see Model.unrestrict_primary_key to change this.
       def setter_methods(only, except)
         only = only.nil? ? model.allowed_columns : only
-        except = except.nil? ? model.restricted_columns : except
+        except = except.nil? ? model._restricted_columns : except
         if only
           only.map{|x| "#{x}="}
         else