sequel 3.43.0 → 3.44.0

data/lib/sequel/core.rb

@@ -380,14 +380,14 @@ module Sequel
   end
 
   # If the supplied block takes a single argument,
-  # yield a new <tt>SQL::VirtualRow</tt> instance to the block
-  # argument.  Otherwise, evaluate the block in the context of a new
+  # yield an <tt>SQL::VirtualRow</tt> instance to the block
+  # argument.  Otherwise, evaluate the block in the context of a
   # <tt>SQL::VirtualRow</tt> instance.
   #
   #   Sequel.virtual_row{a} # Sequel::SQL::Identifier.new(:a)
   #   Sequel.virtual_row{|o| o.a{}} # Sequel::SQL::Function.new(:a)
   def self.virtual_row(&block)
-    vr = SQL::VirtualRow.new
+    vr = VIRTUAL_ROW
     case block.arity
     when -1, 0
       vr.instance_exec(&block)

data/lib/sequel/database/misc.rb

@@ -14,6 +14,10 @@ module Sequel
     # instances.
     DEFAULT_STRING_COLUMN_SIZE = 255
 
+    # Empty exception regexp to class map, used by default if Sequel doesn't
+    # have specific support for the database in use.
+    DEFAULT_DATABASE_ERROR_REGEXPS = {}.freeze
+
     # Register an extension callback for Database objects.  ext should be the
     # extension name symbol, and mod should either be a Module that the
     # database is extended with, or a callable object called with the database
@@ -316,27 +320,59 @@ module Sequel
         obj.respond_to?(:empty?) ? obj.empty? : false
       end
     end
-    
+
     # Which transaction errors to translate, blank by default.
     def database_error_classes
       []
     end
 
+    # A hash with regexp keys and exception class values, used
+    # to match against underlying driver exception messages in
+    # order to raise a more specific Sequel::Error subclass.
+    def database_error_regexps
+      DEFAULT_DATABASE_ERROR_REGEXPS
+    end
+
+    # Return the Sequel::DatabaseError subclass to wrap the given
+    # exception in.
+    def database_error_class(exception, opts)
+      database_specific_error_class(exception, opts) || DatabaseError
+    end
+    
+    # Return a specific Sequel::DatabaseError exception class if
+    # one is appropriate for the underlying exception,
+    # or nil if there is no specific exception class.
+    def database_specific_error_class(exception, opts)
+      return DatabaseDisconnectError if disconnect_error?(exception, opts)
+
+      database_error_regexps.each do |regexp, klass|
+        return klass if exception.message =~ regexp
+      end
+
+      nil
+    end
+    
     # Return true if exception represents a disconnect error, false otherwise.
     def disconnect_error?(exception, opts)
       opts[:disconnect]
     end
     
-    # Convert the given exception to a DatabaseError, keeping message
-    # and traceback.
+    # Convert the given exception to an appropriate Sequel::DatabaseError
+    # subclass, keeping message and traceback.
     def raise_error(exception, opts={})
       if !opts[:classes] || Array(opts[:classes]).any?{|c| exception.is_a?(c)}
-        raise Sequel.convert_exception_class(exception, disconnect_error?(exception, opts) ? DatabaseDisconnectError : DatabaseError)
+        raise Sequel.convert_exception_class(exception, database_error_class(exception, opts))
       else
         raise exception
       end
     end
     
+    # Whether the database supports CREATE OR REPLACE VIEW.  If not, support
+    # will be emulated by dropping the view first. false by default.
+    def supports_create_or_replace_view?
+      false
+    end
+
     # Typecast the value to an SQL::Blob
     def typecast_value_blob(value)
       value.is_a?(Sequel::SQL::Blob) ? value : Sequel::SQL::Blob.new(value)

data/lib/sequel/database/query.rb

@@ -585,7 +585,7 @@ module Sequel
 
     # Remove the cached schema for the given schema name
     def remove_cached_schema(table)
-      @schemas.delete(quote_schema_table(table)) if @schemas
+      Sequel.synchronize{@schemas.delete(quote_schema_table(table))} if @schemas
     end
     
     # Remove the current thread from the list of active transactions

data/lib/sequel/database/schema_methods.rb

@@ -202,24 +202,34 @@ module Sequel
       create_table_generator_class.new(self, &block)
     end
     
-    # Creates a view, replacing it if it already exists:
+    # Creates a view, replacing a view with the same name if one already exists.
     #
-    #   DB.create_or_replace_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
-    #   DB.create_or_replace_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
-    def create_or_replace_view(name, source)
-      source = source.sql if source.is_a?(Dataset)
-      execute_ddl("CREATE OR REPLACE VIEW #{quote_schema_table(name)} AS #{source}")
-      remove_cached_schema(name)
-      nil
+    #   DB.create_or_replace_view(:some_items, "SELECT * FROM items WHERE price < 100")
+    #   DB.create_or_replace_view(:some_items, DB[:items].filter(:category => 'ruby'))
+    #
+    # For databases where replacing a view is not natively supported, support
+    # is emulated by dropping a view with the same name before creating the view.
+    def create_or_replace_view(name, source, options = {})
+      if supports_create_or_replace_view?
+        options = options.merge(:replace=>true)
+      else
+        drop_view(name) rescue nil
+      end
+
+      create_view(name, source, options)
     end
     
     # Creates a view based on a dataset or an SQL string:
     #
     #   DB.create_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
     #   DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
-    def create_view(name, source)
-      source = source.sql if source.is_a?(Dataset)
-      execute_ddl("CREATE VIEW #{quote_schema_table(name)} AS #{source}")
+    #
+    # PostgreSQL/SQLite specific option:
+    # :temp :: Create a temporary view, automatically dropped on disconnect.
+    def create_view(name, source, options = {})
+      execute_ddl(create_view_sql(name, source, options))
+      remove_cached_schema(name)
+      nil
     end
     
     # Removes a column from the specified table:
@@ -581,11 +591,22 @@ module Sequel
       "#{create_table_prefix_sql(name, options)} AS #{sql}"
     end
 
-    # DDL statement for creating a table with the given name, columns, and options
+    # DDL fragment for initial part of CREATE TABLE statement
     def create_table_prefix_sql(name, options)
       "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
     end
 
+    # DDL statement for creating a view.
+    def create_view_sql(name, source, options)
+      source = source.sql if source.is_a?(Dataset)
+      "#{create_view_prefix_sql(name, options)} AS #{source}"
+    end
+
+    # DDL fragment for initial part of CREATE VIEW statement
+    def create_view_prefix_sql(name, options)
+      "CREATE #{'OR REPLACE 'if options[:replace]}VIEW #{quote_schema_table(name)}"
+    end
+
     # Default index name for the table and columns, may be too long
     # for certain databases.
     def default_index_name(table_name, columns)

data/lib/sequel/dataset/actions.rb

@@ -11,7 +11,7 @@ module Sequel
     ACTION_METHODS = (<<-METHS).split.map{|x| x.to_sym}
       << [] []= all avg count columns columns! delete each
       empty? fetch_rows first get import insert insert_multiple interval last
-      map max min multi_insert range select_hash select_hash_groups select_map select_order_map
+      map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
       set single_record single_value sum to_csv to_hash to_hash_groups truncate update
     METHS
 
@@ -80,7 +80,7 @@ module Sequel
     #   # => [:id, :name]
     def columns
       return @columns if @columns
-      ds = unfiltered.unordered.clone(:distinct => nil, :limit => 1, :offset=>nil)
+      ds = unfiltered.unordered.naked.clone(:distinct => nil, :limit => 1, :offset=>nil)
       ds.each{break}
       @columns = ds.instance_variable_get(:@columns)
       @columns || []
@@ -461,6 +461,55 @@ module Sequel
       import(columns, hashes.map{|h| columns.map{|c| h[c]}}, opts)
     end
 
+    # Yields each row in the dataset, but interally uses multiple queries as needed with
+    # limit and offset to process the entire result set without keeping all
+    # rows in the dataset in memory, even if the underlying driver buffers all
+    # query results in memory.
+    #
+    # Because this uses multiple queries internally, in order to remain consistent,
+    # it also uses a transaction internally.  Additionally, to make sure that all rows
+    # in the dataset are yielded and none are yielded twice, the dataset must have an
+    # unambiguous order.  Sequel requires that datasets using this method have an
+    # order, but it cannot ensure that the order is unambiguous.
+    #
+    # Options:
+    # :rows_per_fetch :: The number of rows to fetch per query.  Defaults to 1000.
+    def paged_each(opts={})
+      unless @opts[:order]
+        raise Sequel::Error, "Dataset#paged_each requires the dataset be ordered"
+      end
+
+      total_limit = @opts[:limit]
+      offset = @opts[:offset] || 0
+
+      if server = @opts[:server]
+        opts = opts.merge(:server=>server)
+      end
+
+      rows_per_fetch = opts[:rows_per_fetch] || 1000
+      num_rows_yielded = rows_per_fetch
+      total_rows = 0
+
+      db.transaction(opts) do
+        while num_rows_yielded == rows_per_fetch && (total_limit.nil? || total_rows < total_limit)
+          if total_limit && total_rows + rows_per_fetch > total_limit
+            rows_per_fetch = total_limit - total_rows
+          end
+
+          num_rows_yielded = 0
+          limit(rows_per_fetch, offset).each do |row|
+            num_rows_yielded += 1
+            total_rows += 1 if total_limit
+            yield row
+          end
+
+          offset += rows_per_fetch
+        end
+      end
+
+      self
+    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.
     #

data/lib/sequel/dataset/features.rb

@@ -159,12 +159,6 @@ module Sequel
       true
     end
 
-    # Whether using an offset returns an extra row number column that should be
-    # eliminated, false by default.
-    def offset_returns_row_number_column?
-      false
-    end
-
     # Whether the RETURNING clause is used for the given dataset.
     # +type+ can be :insert, :update, or :delete.
     def uses_returning?(type)

data/lib/sequel/dataset/sql.rb

@@ -654,7 +654,7 @@ module Sequel
       when SQL::Identifier
         [sch, table_name.value.to_s]
       when String
-        [sch, table_name.to_s]
+        [sch, table_name]
       else
         raise Error, 'table_name should be a Symbol, SQL::QualifiedIdentifier, SQL::Identifier, or String'
       end

data/lib/sequel/exceptions.rb

@@ -19,32 +19,47 @@ module Sequel
   # connection parameters it was given.
   class DatabaseConnectionError < DatabaseError; end
 
-  # Error that should be raised by adapters when they determine that the connection
+  # Error raised by adapters when they determine that the connection
   # to the database has been lost.  Instructs the connection pool code to 
   # remove that connection from the pool so that other connections can be acquired
   # automatically.
   class DatabaseDisconnectError < DatabaseError; end
 
-  # Raised on an invalid operation, such as trying to update or delete
+  # Generic error raised when Sequel determines a database constraint has been violated.
+  class ConstraintViolation < DatabaseError; end
+
+  # Error raised when Sequel determines a database check constraint has been violated.
+  class CheckConstraintViolation < ConstraintViolation; end
+
+  # Error raised when Sequel determines a database foreign key constraint has been violated.
+  class ForeignKeyConstraintViolation < ConstraintViolation; end
+
+  # Error raised when Sequel determines a database NOT NULL constraint has been violated.
+  class NotNullConstraintViolation < ConstraintViolation; end
+
+  # Error raised when Sequel determines a database unique constraint has been violated.
+  class UniqueConstraintViolation < ConstraintViolation; end
+
+  # Error raised on an invalid operation, such as trying to update or delete
   # a joined or grouped dataset.
   class InvalidOperation < Error; end
 
-  # Raised when attempting an invalid type conversion.
+  # Error raised when attempting an invalid type conversion.
   class InvalidValue < Error ; end
 
-  # Raised when the adapter adapter hasn't implemented a method such as +tables+:
+  # Error raised when the adapter adapter hasn't implemented a method such as +tables+:
   class NotImplemented < Error; end
 
-  # Raised when the connection pool cannot acquire a database connection
+  # Error raised when the connection pool cannot acquire a database connection
   # before the timeout.
   class PoolTimeout < Error ; end
 
   # Exception that you should raise to signal a rollback of the current transaction.
   # The transaction block will catch this exception, rollback the current transaction,
-  # and won't reraise it.
+  # and won't reraise it (unless a reraise is requested).
   class Rollback < Error ; end
 
-  # Exception that occurs when unbinding a dataset that has multiple different values
+  # Error raised when unbinding a dataset that has multiple different values
   # for a given variable.
   class UnbindDuplicate < Error; end
 

data/lib/sequel/extensions/columns_introspection.rb

@@ -2,8 +2,10 @@
 # selected columns for a dataset before issuing a query.  If it
 # thinks it can guess correctly at the columns the query will use,
 # it will return the columns without issuing a database query.
+#
 # This method is not fool-proof, it's possible that some databases
-# will use column names that Sequel does not expect.
+# will use column names that Sequel does not expect.  Also, it
+# may not correctly handle all cases. 
 #
 # To attempt to introspect columns for a single dataset:
 #
@@ -27,15 +29,38 @@ module Sequel
     # SQL::AliasedExpressions.
     def columns
       return @columns if @columns
-      return columns_without_introspection unless cols = opts[:select] and !cols.empty?
-      probable_columns = cols.map{|c| probable_column_name(c)}
-      if probable_columns.all?
-        @columns = probable_columns
+      if (pcs = probable_columns) && pcs.all?
+        @columns = pcs
       else
         columns_without_introspection
       end
     end
 
+    protected
+
+    # Return an array of probable column names for the dataset, or
+    # nil if it is not possible to determine that through
+    # introspection.
+    def probable_columns
+      if (cols = opts[:select]) && !cols.empty?
+        cols.map{|c| probable_column_name(c)}
+      elsif !opts[:join] && !opts[:with] && (from = opts[:from]) && from.length == 1 && (from = from.first)
+        if from.is_a?(SQL::AliasedExpression)
+          from = from.expression
+        end
+        
+        case from
+        when Dataset
+          from.probable_columns
+        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
+          schemas = db.instance_variable_get(:@schemas)
+          if schemas && (sch = Sequel.synchronize{schemas[literal(from)]})
+            sch.map{|c,_| c}
+          end
+        end
+      end
+    end
+
     private
 
     # Return the probable name of the column, or nil if one

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -102,6 +102,15 @@ module Sequel
           end
           super
         end
+
+        private
+
+        def create_view_sql(name, source, options)
+          if source.is_a?(DatasetMethods)
+            source = source.no_auto_parameterize
+          end
+          super
+        end
       end
 
       module DatasetMethods

data/lib/sequel/model/associations.rb

@@ -22,11 +22,6 @@ module Sequel
           :"_add_#{singularize(self[:name])}"
         end
       
-        # Name symbol for the _dataset association method
-        def _dataset_method
-          :"_#{self[:name]}_dataset"
-        end
-      
         # Name symbol for the _remove_all internal association method
         def _remove_all_method
           :"_remove_all_#{self[:name]}"
@@ -56,6 +51,29 @@ module Sequel
         def associated_class
           cached_fetch(:class){constantize(self[:class_name])}
         end
+
+        # The dataset associated via this association, with the non-instance specific
+        # changes already applied.
+        def associated_dataset
+          cached_fetch(:_dataset){apply_dataset_changes(associated_class.dataset.clone)}
+        end
+
+        # Apply all non-instance specific changes to the given dataset and return it.
+        def apply_dataset_changes(ds)
+          ds.extend(AssociationDatasetMethods)
+          ds.association_reflection = self
+          self[:extend].each{|m| ds.extend(m)}
+          ds = ds.select(*select) if select
+          if c = self[:conditions]
+            ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
+          end
+          ds = ds.order(*self[:order]) if self[:order]
+          ds = ds.limit(*self[:limit]) if self[:limit]
+          ds = ds.limit(1) if !returns_array? && self[:key]
+          ds = ds.eager(*self[:eager]) if self[:eager]
+          ds = ds.distinct if self[:distinct]
+          ds
+        end
         
         # Whether this association can have associated objects, given the current
         # object.  Should be false if obj cannot have associated objects because
@@ -688,7 +706,7 @@ module Sequel
         def apply_association_dataset_opts(opts, ds)
           ds = ds.select(*opts.select) if opts.select
           if c = opts[:conditions]
-            ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
           end
           ds = ds.order(*opts[:order]) if opts[:order]
           ds = ds.eager(opts[:eager]) if opts[:eager]
@@ -747,9 +765,10 @@ module Sequel
         # :clone :: Merge the current options and block into the options and block used in defining
         #           the given association.  Can be used to DRY up a bunch of similar associations that
         #           all share the same options such as :class and :key, while changing the order and block used.
-        # :conditions :: The conditions to use to filter the association, can be any argument passed to filter.
-        # :dataset :: A proc that is instance_evaled to get the base dataset
-        #             to use for the _dataset method (before the other options are applied).
+        # :conditions :: The conditions to use to filter the association, can be any argument passed to where.
+        # :dataset :: A proc that is instance_execed to get the base dataset to use (before the other
+        #             options are applied).  If the proc accepts an argument, it is passed the related
+        #             association reflection.
         # :distinct :: Use the DISTINCT clause when selecting associating object, both when
         #              lazy loading and eager loading via .eager (but not when using .eager_graph).
         # :eager :: The associations to eagerly load via +eager+ when loading the associated object(s).
@@ -1047,7 +1066,7 @@ module Sequel
           else
             SQL::QualifiedIdentifier.new(table, pk)
           end
-          ds.filter(pk=>subquery)
+          ds.where(pk=>subquery)
         end
 
         # Use a window function to limit the results of the eager loading dataset.
@@ -1091,7 +1110,6 @@ module Sequel
       
         # Adds the association dataset methods to the association methods module.
         def def_association_dataset_methods(opts)
-          association_module_private_def(opts._dataset_method, opts, &opts[:dataset])
           association_module_def(opts.dataset_method, opts){_dataset(opts)}
           def_association_method(opts)
         end
@@ -1127,7 +1145,7 @@ module Sequel
           graph_jt_conds = opts[:graph_join_table_conditions] = opts.fetch(:graph_join_table_conditions, []).to_a
           opts[:graph_join_table_join_type] ||= opts[:graph_join_type]
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
-          opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, rcks.zip(opts.right_primary_keys) + opts.predicate_keys.zip(lcpks.map{|k| send(k)}), :qualify=>:deep)}
+          opts[:dataset] ||= proc{opts.associated_dataset.inner_join(join_table, rcks.zip(opts.right_primary_keys) + opts.predicate_keys.zip(lcpks.map{|k| send(k)}), :qualify=>:deep)}
 
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:id_map]
@@ -1190,10 +1208,10 @@ module Sequel
             _join_table_dataset(opts).insert(h)
           end
           association_module_private_def(opts._remove_method, opts) do |o|
-            _join_table_dataset(opts).filter(lcks.zip(lcpks.map{|k| send(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.send(k)})).delete
+            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| send(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.send(k)})).delete
           end
           association_module_private_def(opts._remove_all_method, opts) do
-            _join_table_dataset(opts).filter(lcks.zip(lcpks.map{|k| send(k)})).delete
+            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| send(k)})).delete
           end
       
           def_add_method(opts)
@@ -1219,8 +1237,7 @@ module Sequel
           qualify = opts[:qualify] != false
           opts[:cartesian_product_number] ||= 0
           opts[:dataset] ||= proc do
-            klass = opts.associated_class
-            klass.filter(opts.predicate_keys.zip(cks.map{|k| send(k)}))
+            opts.associated_dataset.where(opts.predicate_keys.zip(cks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:id_map]
@@ -1231,7 +1248,7 @@ module Sequel
             # Skip eager loading if no objects have a foreign key for this association
             unless keys.empty?
               klass = opts.associated_class
-              model.eager_loading_dataset(opts, klass.filter(opts.predicate_key=>keys), nil, eo[:associations], eo).all do |assoc_record|
+              model.eager_loading_dataset(opts, klass.where(opts.predicate_key=>keys), nil, eo[:associations], eo).all do |assoc_record|
                 hash_key = uses_cks ? opts.primary_key_methods.map{|k| assoc_record.send(k)} : assoc_record.send(opts.primary_key_method)
                 next unless objects = h[hash_key]
                 objects.each{|object| object.associations[name] = assoc_record}
@@ -1276,7 +1293,7 @@ module Sequel
           raise(Error, "mismatched number of keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
           uses_cks = opts[:uses_composite_keys] = cks.length > 1
           opts[:dataset] ||= proc do
-            opts.associated_class.filter(opts.predicate_keys.zip(cpks.map{|k| send(k)}))
+            opts.associated_dataset.where(opts.predicate_keys.zip(cpks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:id_map]
@@ -1289,7 +1306,7 @@ module Sequel
             reciprocal = opts.reciprocal
             klass = opts.associated_class
             filter_keys = opts.predicate_key
-            ds = model.eager_loading_dataset(opts, klass.filter(filter_keys=>h.keys), nil, eo[:associations], eo)
+            ds = model.eager_loading_dataset(opts, klass.where(filter_keys=>h.keys), nil, eo[:associations], eo)
             case opts.eager_limit_strategy
             when :distinct_on
               ds = ds.distinct(*filter_keys).order_prepend(*filter_keys)
@@ -1351,7 +1368,7 @@ module Sequel
 
             if one_to_one
               association_module_private_def(opts._setter_method, opts) do |o|
-                up_ds = _apply_association_options(opts, opts.associated_class.filter(cks.zip(cpks.map{|k| send(k)})))
+                up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| send(k)})))
                 if o
                   up_ds = up_ds.exclude(o.pk_hash) unless o.new?
                   cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
@@ -1374,7 +1391,7 @@ module Sequel
                 o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save")
               end
               association_module_private_def(opts._remove_all_method, opts) do
-                _apply_association_options(opts, opts.associated_class.filter(cks.zip(cpks.map{|k| send(k)}))).update(ck_nil_hash)
+                _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| send(k)}))).update(ck_nil_hash)
               end
               def_remove_methods(opts)
             end
@@ -1430,19 +1447,10 @@ module Sequel
         
         # Apply the association options such as :order and :limit to the given dataset, returning a modified dataset.
         def _apply_association_options(opts, ds)
-          ds.extend(AssociationDatasetMethods)
-          ds.model_object = self
-          ds.association_reflection = opts
-          opts[:extend].each{|m| ds.extend(m)}
-          ds = ds.select(*opts.select) if opts.select
-          if c = opts[:conditions]
-            ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+          unless ds.kind_of?(AssociationDatasetMethods)
+            ds = opts.apply_dataset_changes(ds)
           end
-          ds = ds.order(*opts[:order]) if opts[:order]
-          ds = ds.limit(*opts[:limit]) if opts[:limit]
-          ds = ds.limit(1) if !opts.returns_array? && opts[:key]
-          ds = ds.eager(*opts[:eager]) if opts[:eager]
-          ds = ds.distinct if opts[:distinct]
+          ds.model_object = self
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
           ds = instance_exec(ds, &opts[:block]) if opts[:block]
           ds
@@ -1460,7 +1468,12 @@ module Sequel
         # Return an association dataset for the given association reflection
         def _dataset(opts)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
-          _apply_association_options(opts, send(opts._dataset_method))
+          ds = if opts[:dataset].arity == 1
+            instance_exec(opts, &opts[:dataset])
+          else
+            instance_exec(&opts[:dataset])
+          end
+          _apply_association_options(opts, ds)
         end
 
         # Dataset for the join table of the given many to many association reflection
@@ -1601,7 +1614,7 @@ module Sequel
             o = remove_check_existing_object_from_pk(opts, o, *args)
           elsif !o.is_a?(klass)
             raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
-          elsif opts.remove_should_check_existing? && send(opts.dataset_method).filter(o.pk_hash).empty?
+          elsif opts.remove_should_check_existing? && send(opts.dataset_method).where(o.pk_hash).empty?
             raise(Sequel::Error, "associated object #{o.inspect} is not currently associated to #{inspect}")
           end
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") unless pk
@@ -1723,7 +1736,7 @@ module Sequel
       # allows you to customize it at association definition time. For example,
       # if you wanted artists with their albums since 1990:
       #
-      #   Artist.eager(:albums => proc{|ds| ds.filter{year > 1990}})
+      #   Artist.eager(:albums => proc{|ds| ds.where{year > 1990}})
       #
       # Or if you needed albums and their artist's name only, using a single query:
       #
@@ -1734,7 +1747,7 @@ module Sequel
       # the cascaded associations as the value.  This will load artists with their albums
       # since 1990, and also the tracks on those albums and the genre for those tracks:
       #
-      #   Artist.eager(:albums => {proc{|ds| ds.filter{year > 1990}}=>{:tracks => :genre}})
+      #   Artist.eager(:albums => {proc{|ds| ds.where{year > 1990}}=>{:tracks => :genre}})
       module DatasetMethods
         # Add the <tt>eager!</tt> and <tt>eager_graph!</tt> mutation methods to the dataset.
         def self.extended(obj)