sequel 5.58.0 → 5.78.0

data/lib/sequel/extensions/schema_dumper.rb

@@ -88,11 +88,11 @@ module Sequel
     # Note that the migration this produces does not have a down
     # block, so you cannot reverse it.
     def dump_foreign_key_migration(options=OPTS)
-      ts = tables(options)
+      ts = _dump_tables(options)
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
+#{ts.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
@@ -106,11 +106,11 @@ END_MIG
     #                 set to :namespace, prepend the table name to the index name if the
     #                 database does not use a global index namespace.
     def dump_indexes_migration(options=OPTS)
-      ts = tables(options)
+      ts = _dump_tables(options)
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
+#{ts.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
@@ -138,7 +138,7 @@ END_MIG
         options[:foreign_keys] = false
       end
 
-      ts = sort_dumped_tables(tables(options), options)
+      ts = sort_dumped_tables(_dump_tables(options), options)
       skipped_fks = if sfk = options[:skipped_foreign_keys]
         # Handle skipped foreign keys by adding them at the end via
         # alter_table/add_foreign_key.  Note that skipped foreign keys
@@ -166,6 +166,21 @@ END_MIG
 
     private
         
+    # Handle schema option to dump tables in a different schema. Such
+    # tables must be schema qualified for this to work correctly.
+    def _dump_tables(opts)
+      if opts[:schema]
+        _literal_table_sort(tables(opts.merge(:qualify=>true)))
+      else
+        tables(opts).sort
+      end
+    end
+
+    # Sort the given table by the literalized value.
+    def _literal_table_sort(tables)
+      tables.sort_by{|s| literal(s)}
+    end
+
     # If a database default exists and can't be converted, and we are dumping with :same_db,
     # return a string with the inspect method modified a literal string is created if the code is evaled.  
     def column_schema_to_ruby_default_fallback(default, options)
@@ -204,12 +219,20 @@ END_MIG
           if database_type == :mysql && h[:type] =~ /\Atimestamp/
             h[:null] = true
           end
+          if database_type == :mssql && schema[:max_length]
+            h[:size] = schema[:max_length]
+          end
           h
         else
           column_schema_to_ruby_type(schema)
         end
         type = col_opts.delete(:type)
-        col_opts.delete(:size) if col_opts[:size].nil?
+        if col_opts.key?(:size) && col_opts[:size].nil?
+          col_opts.delete(:size)
+          if max_length = schema[:max_length]
+            col_opts[:size] = max_length
+          end
+        end
         if schema[:generated]
           if options[:same_db] && database_type == :postgres
             col_opts[:generated_always_as] = column_schema_to_ruby_default_fallback(schema[:default], options)
@@ -352,7 +375,7 @@ END_MIG
         options[:skipped_foreign_keys] = skipped_foreign_keys
         tables
       else
-        tables.sort
+        tables
       end
     end
 
@@ -377,14 +400,14 @@ END_MIG
           # outstanding foreign keys and skipping those foreign keys.
           # The skipped foreign keys will be added at the end of the
           # migration.
-          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table]}.first
+          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, literal(table)]}.first
           skip_fks_hash = skipped_foreign_keys[skip_table] = {}
           skip_fks.each{|fk| skip_fks_hash[fk[:columns]] = fk}
           this_loop << skip_table
         end
 
         # Add sorted tables from this loop to the final list
-        sorted_tables.concat(this_loop.sort)
+        sorted_tables.concat(_literal_table_sort(this_loop))
 
         # Remove tables that were handled this loop
         this_loop.each{|t| table_fks.delete(t)}

data/lib/sequel/extensions/server_block.rb

@@ -69,7 +69,8 @@ module Sequel
     # Also defines the with_server method on the receiver for easy use.
     def self.extended(db)
       pool = db.pool
-      if defined?(ShardedThreadedConnectionPool) && pool.is_a?(ShardedThreadedConnectionPool)
+      case pool.pool_type
+      when :sharded_threaded, :sharded_timed_queue
         pool.extend(ThreadedServerBlock)
         pool.instance_variable_set(:@default_servers, {})
       else

data/lib/sequel/extensions/set_literalizer.rb

@@ -0,0 +1,58 @@
+# frozen-string-literal: true
+#
+# The set_literalizer extension allows for using Set instances in many of the
+# same places that you would use Array instances:
+#
+#   DB[:table].where(column: Set.new([1, 2, 3]))
+#   # SELECT FROM table WHERE (column IN (1, 2, 3))
+#
+# To load the extension into all datasets created from a given Database:
+#
+#   DB.extension :set_literalizer
+#
+# Related module: Sequel::Dataset::SetLiteralizer
+
+require 'set'
+
+module Sequel
+  class Dataset
+    module SetLiteralizer
+      # Try to generate the same SQL for Set instances used in datasets
+      # that would be used for equivalent Array instances.
+      def complex_expression_sql_append(sql, op, args)
+        # Array instances are treated specially by
+        # Sequel::SQL::BooleanExpression.from_value_pairs. That cannot
+        # be modified by a dataset extension, so this tries to convert
+        # the complex expression values generated by default to what would
+        # be the complex expression values used for the equivalent array.
+        case op
+        when :'=', :'!='
+          if (set = args[1]).is_a?(Set)
+            op = op == :'=' ? :IN : :'NOT IN'
+            col = args[0]
+            array = set.to_a
+            if Sequel.condition_specifier?(array) && col.is_a?(Array)
+              array = Sequel.value_list(array)
+            end
+            args = [col, array]
+          end
+        end
+
+        super
+      end
+
+      private
+
+      # Literalize Set instances by converting the set to array.
+      def literal_other_append(sql, v)
+        if Set === v
+          literal_append(sql, v.to_a) 
+        else
+          super
+        end
+      end
+    end
+
+    register_extension(:set_literalizer, SetLiteralizer)
+  end
+end

data/lib/sequel/extensions/sqlite_json_ops.rb

@@ -2,27 +2,34 @@
 #
 # The sqlite_json_ops extension adds support to Sequel's DSL to make
 # it easier to call SQLite JSON functions and operators (added
-# first in SQLite 3.38.0).
+# first in SQLite 3.38.0).  It also supports the SQLite JSONB functions
+# added in SQLite 3.45.0.
 #
 # To load the extension:
 #
 #   Sequel.extension :sqlite_json_ops
 #
-# This extension works by calling methods on Sequel::SQLite::JSONOp objects,
-# which you can create via Sequel.sqlite_json_op:
+# This extension works by calling methods on Sequel::SQLite::JSONOp and
+# Sequel::SQLite::JSONBOp objects, which you can create using
+# Sequel.sqlite_json_op and Sequel.sqlite_jsonb_op:
 #
 #   j = Sequel.sqlite_json_op(:json_column)
+#   jb = Sequel.sqlite_jsonb_op(:jsonb_column)
 #
-# Also, on most Sequel expression objects, you can call the sqlite_json_op method
-# to create a Sequel::SQLite::JSONOp object:
+# Also, on most Sequel expression objects, you can call the sqlite_json_op or
+# sqlite_jsonb_op method to create a Sequel::SQLite::JSONOp or 
+# Sequel::SQLite::JSONBOp object:
 #
 #   j = Sequel[:json_column].sqlite_json_op
+#   jb = Sequel[:jsonb_column].sqlite_jsonb_op
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
 # and have activated refinements for the file, you can also use Symbol#sqlite_json_op:
+# or Symbol#sqlite_jsonb_op:
 #
 #   j = :json_column.sqlite_json_op
+#   jb = :json_column.sqlite_jsonb_op
 #
 # The following methods are available for Sequel::SQLite::JSONOp instances:
 #
@@ -30,11 +37,13 @@
 #   j.get(1)                 # (json_column ->> 1)
 #   j.get_text(1)            # (json_column -> 1)
 #   j.extract('$.a')         # json_extract(json_column, '$.a')
+#   jb.extract('$.a')        # jsonb_extract(jsonb_column, '$.a')
 #
 #   j.array_length           # json_array_length(json_column)
 #   j.type                   # json_type(json_column)
 #   j.valid                  # json_valid(json_column)
-#   j.json                   # json(json_column)
+#   jb.json                  # json(jsonb_column)
+#   j.jsonb                  # jsonb(json_column)
 #
 #   j.insert('$.a', 1)       # json_insert(json_column, '$.a', 1)
 #   j.set('$.a', 1)          # json_set(json_column, '$.a', 1)
@@ -42,22 +51,30 @@
 #   j.remove('$.a')          # json_remove(json_column, '$.a')
 #   j.patch('{"a":2}')       # json_patch(json_column, '{"a":2}')
 #
+#   jb.insert('$.a', 1)      # jsonb_insert(jsonb_column, '$.a', 1)
+#   jb.set('$.a', 1)         # jsonb_set(jsonb_column, '$.a', 1)
+#   jb.replace('$.a', 1)     # jsonb_replace(jsonb_column, '$.a', 1)
+#   jb.remove('$.a')         # jsonb_remove(jsonb_column, '$.a')
+#   jb.patch('{"a":2}')      # jsonb_patch(jsonb_column, '{"a":2}')
+#
 #   j.each                   # json_each(json_column)
 #   j.tree                   # json_tree(json_column)
 #
-# Related modules: Sequel::SQLite::JSONOp
+# Related modules: Sequel::SQLite::JSONBaseOp, Sequel::SQLite::JSONOp,
+# Sequel::SQLite::JSONBOp
 
 #
 module Sequel
   module SQLite
-    # The JSONOp class is a simple container for a single object that
-    # defines methods that yield Sequel expression objects representing
-    # SQLite json operators and functions.
+    # JSONBaseOp is an abstract base wrapper class for a object that
+    # defines methods that return Sequel expression objects representing
+    # SQLite json operators and functions. It is subclassed by both
+    # JSONOp and JSONBOp for json and jsonb specific behavior.
     #
     # In the method documentation examples, assume that:
     #
     #   json_op = Sequel.sqlite_json_op(:json)
-    class JSONOp < Sequel::SQL::Wrapper
+    class JSONBaseOp < Sequel::SQL::Wrapper
       GET = ["(".freeze, " ->> ".freeze, ")".freeze].freeze
       private_constant :GET
 
@@ -82,7 +99,7 @@ module Sequel
       #   json_op.array_length         # json_array_length(json)
       #   json_op.array_length('$[1]') # json_array_length(json, '$[1]')
       def array_length(*args)
-        Sequel::SQL::NumericExpression.new(:NOOP, function(:array_length, *args))
+        Sequel::SQL::NumericExpression.new(:NOOP, SQL::Function.new(:json_array_length, self, *args))
       end
 
       # Returns an expression for a set of information extracted from the top-level
@@ -92,7 +109,7 @@ module Sequel
       #   json_op.each        # json_each(json)
       #   json_op.each('$.a') # json_each(json, '$.a')
       def each(*args)
-        function(:each, *args)
+        SQL::Function.new(:json_each, self, *args)
       end
 
       # Returns an expression for the JSON array element or object field at the specified
@@ -129,10 +146,17 @@ module Sequel
       #
       #   json_op.json   # json(json)
       def json
-        self.class.new(SQL::Function.new(:json, self))
+        JSONOp.new(SQL::Function.new(:json, self))
       end
       alias minify json
 
+      # Returns the JSONB format of the JSON.
+      #
+      #   json_op.jsonb   # jsonb(json)
+      def jsonb
+        JSONBOp.new(SQL::Function.new(:jsonb, self))
+      end
+
       # Returns an expression for updating the JSON object using the RFC 7396 MergePatch algorithm
       #
       #   json_op.patch('{"a": 1, "b": null}') # json_patch(json, '{"a": 1, "b": null}')
@@ -172,7 +196,7 @@ module Sequel
       #   json_op.tree        # json_tree(json)
       #   json_op.tree('$.a') # json_tree(json, '$.a')
       def tree(*args)
-        function(:tree, *args)
+        SQL::Function.new(:json_tree, self, *args)
       end
 
       # Returns an expression for the type of the JSON value or the JSON value at the given path.
@@ -180,13 +204,13 @@ module Sequel
       #   json_op.type         # json_type(json)
       #   json_op.type('$[1]') # json_type(json, '$[1]')
       def type(*args)
-        Sequel::SQL::StringExpression.new(:NOOP, function(:type, *args))
+        Sequel::SQL::StringExpression.new(:NOOP, SQL::Function.new(:json_type, self, *args))
       end
       alias typeof type
 
       # Returns a boolean expression for whether the JSON is valid or not.
       def valid
-        Sequel::SQL::BooleanExpression.new(:NOOP, function(:valid))
+        Sequel::SQL::BooleanExpression.new(:NOOP, SQL::Function.new(:json_valid, self))
       end
 
       private
@@ -198,7 +222,7 @@ module Sequel
 
       # Internals of the methods that return functions prefixed with +json_+.
       def function(name, *args)
-        SQL::Function.new("json_#{name}", self, *args)
+        SQL::Function.new("#{function_prefix}_#{name}", self, *args)
       end
 
       # Internals of the methods that return functions prefixed with +json_+, that
@@ -208,12 +232,36 @@ module Sequel
       end
     end
 
+    # JSONOp is used for SQLite json-specific functions and operators.
+    class JSONOp < JSONBaseOp
+      private
+
+      def function_prefix
+        "json"
+      end
+    end
+
+    # JSONOp is used for SQLite jsonb-specific functions and operators.
+    class JSONBOp < JSONBaseOp
+      private
+
+      def function_prefix
+        "jsonb"
+      end
+    end
+
     module JSONOpMethods
       # Wrap the receiver in an JSONOp so you can easily use the SQLite
       # json functions and operators with it.
       def sqlite_json_op
         JSONOp.new(self)
       end
+
+      # Wrap the receiver in an JSONBOp so you can easily use the SQLite
+      # jsonb functions and operators with it.
+      def sqlite_jsonb_op
+        JSONBOp.new(self)
+      end
     end
   end
 
@@ -227,6 +275,16 @@ module Sequel
         SQLite::JSONOp.new(v)
       end
     end
+
+    # Return the object wrapped in an SQLite::JSONBOp.
+    def sqlite_jsonb_op(v)
+      case v
+      when SQLite::JSONBOp
+        v
+      else
+        SQLite::JSONBOp.new(v)
+      end
+    end
   end
 
   class SQL::GenericExpression

data/lib/sequel/extensions/symbol_aref.rb

@@ -35,6 +35,7 @@ if RUBY_VERSION >= '2.0'
   class Symbol
     prepend Sequel::SymbolAref
   end
+# :nocov:
 else
   class Symbol
     if method_defined?(:[])
@@ -51,3 +52,4 @@ else
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/transaction_connection_validator.rb

@@ -0,0 +1,78 @@
+# frozen-string-literal: true
+#
+# The transaction_connection_validator extension automatically
+# retries a transaction on a connection if an disconnect error
+# is raised when sending the statement to begin a new
+# transaction, as long as the user has not already checked out
+# a connection.  This is safe to do because no other queries
+# have been issued on the connection, and no user-level code
+# is run before retrying.
+#
+# This approach to connection validation can be significantly
+# lower overhead than the connection_validator extension,
+# though it does not handle all cases handled by the
+# connection_validator extension.  However, it performs the
+# validation checks on every new transaction, so it will
+# automatically handle disconnected connections in some cases
+# where the connection_validator extension will not by default
+# (as the connection_validator extension only checks
+# connections if they have not been used in the last hour by
+# default).
+#
+# Related module: Sequel::TransactionConnectionValidator
+
+#
+module Sequel
+  module TransactionConnectionValidator
+    class DisconnectRetry < DatabaseDisconnectError
+      # The connection that raised the disconnect error
+      attr_accessor :connection
+
+      # The underlying disconnect error, in case it needs to be reraised.
+      attr_accessor :database_error
+    end
+
+    # Rescue disconnect errors raised when beginning a new transaction.  If there
+    # is a disconnnect error, it should be safe to retry the transaction using a
+    # new connection, as we haven't yielded control to the user yet.
+    def transaction(opts=OPTS)
+      super
+    rescue DisconnectRetry => e
+      if synchronize(opts[:server]){|conn| conn.equal?(e.connection)}
+        # If retrying would use the same connection, that means the
+        # connection was not removed from the pool, which means the caller has
+        # already checked out the connection, and retrying will not be successful.
+        # In this case, we can only reraise the exception.
+        raise e.database_error
+      end
+
+      num_retries ||= 0 
+      num_retries += 1
+      retry if num_retries < 5
+
+      raise e.database_error
+    end
+
+    private
+
+    # Reraise disconnect errors as DisconnectRetry so they can be retried.
+    def begin_new_transaction(conn, opts)
+      super
+    rescue Sequel::DatabaseDisconnectError, *database_error_classes => e
+      if e.is_a?(Sequel::DatabaseDisconnectError) || disconnect_error?(e, OPTS)
+        exception = DisconnectRetry.new(e.message)
+        exception.set_backtrace([])
+        exception.connection = conn
+        unless e.is_a?(Sequel::DatabaseError)
+          e = Sequel.convert_exception_class(e, database_error_class(e, OPTS))
+        end
+        exception.database_error = e
+        raise exception
+      end
+
+      raise
+    end
+  end
+
+  Database.register_extension(:transaction_connection_validator, TransactionConnectionValidator)
+end

data/lib/sequel/model/associations.rb

@@ -276,7 +276,7 @@ module Sequel
 
           if eo[:no_results]
             no_results = true
-          elsif eo[:eager_block] || eo[:loader] == false
+          elsif eo[:eager_block] || eo[:loader] == false || !use_placeholder_loader?
             ds = eager_loading_dataset(eo)
 
             strategy = ds.opts[:eager_limit_strategy] || strategy
@@ -299,13 +299,28 @@ module Sequel
             strategy = :ruby if strategy == :correlated_subquery
             strategy = nil if strategy == :ruby && assign_singular?
             objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
+
+            if strategy == :window_function
+              delete_rn = ds.row_number_column 
+              objects.each{|obj| obj.values.delete(delete_rn)}
+            end
           elsif strategy == :union
             objects = []
             ds = associated_dataset
             loader = union_eager_loader
             joiner = " UNION ALL "
             ids.each_slice(subqueries_per_union).each do |slice|
-              objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a)
+              sql = loader.send(:sql_origin)
+              join = false
+              slice.each do |k|
+                if join
+                  sql << joiner
+                else
+                  join = true
+                end
+                loader.append_sql(sql, *k)
+              end
+              objects.concat(ds.with_sql(sql).to_a)
             end
             ds = ds.eager(cascade) if cascade
             ds.send(:post_load, objects)
@@ -441,7 +456,7 @@ module Sequel
         def placeholder_loader
           if use_placeholder_loader?
             cached_fetch(:placeholder_loader) do
-              Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
+              associated_dataset.placeholder_literalizer_loader do |pl, ds|
                 ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
                 if self[:block]
                   ds = self[:block].call(ds)
@@ -743,8 +758,8 @@ module Sequel
         # A placeholder literalizer used to speed up eager loading.
         def placeholder_eager_loader
           cached_fetch(:placeholder_eager_loader) do
-            Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
-              apply_eager_limit_strategy(eager_loading_dataset.where(predicate_key=>pl.arg), eager_limit_strategy)
+            eager_loading_dataset.placeholder_literalizer_loader do |pl, ds|
+              apply_eager_limit_strategy(ds.where(predicate_key=>pl.arg), eager_limit_strategy)
             end
           end
         end
@@ -803,7 +818,7 @@ module Sequel
         # loading a limited association.
         def union_eager_loader
           cached_fetch(:union_eager_loader) do
-            Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
+            associated_dataset.placeholder_literalizer_loader do |pl, ds|
               ds = self[:eager_block].call(ds) if self[:eager_block]
               keys = predicate_keys
               ds = ds.where(keys.map{pl.arg}.zip(keys))
@@ -817,7 +832,7 @@ module Sequel
 
         # Whether the placeholder loader can be used to load the association.
         def use_placeholder_loader?
-          self[:use_placeholder_loader]
+          self[:use_placeholder_loader] && _associated_dataset.supports_placeholder_literalizer?
         end
       end
     
@@ -1717,6 +1732,10 @@ module Sequel
         # :graph_select :: A column or array of columns to select from the associated table
         #                  when eagerly loading the association via +eager_graph+. Defaults to all
         #                  columns in the associated table.
+        # :graph_use_association_block :: Makes eager_graph consider the association block. Without this, eager_graph
+        #                                 ignores the bock and only use the :graph_* options.
+        # :instance_specific :: Marks the association as instance specific. Should be used if the association block
+        #                       uses instance specific state, or transient state (accessing current date/time, etc.).
         # :limit :: Limit the number of records to the provided value.  Use
         #           an array with two elements for the value to specify a
         #           limit (first element) and an offset (second element).
@@ -1856,6 +1875,16 @@ module Sequel
             # in certain places to disable optimizations.
             opts[:instance_specific] = _association_instance_specific_default(name)
           end
+          if (orig_opts[:instance_specific] || orig_opts[:dataset]) && !opts.has_key?(:allow_eager) && !opts[:eager_loader]
+            # For associations explicitly marked as instance specific, or that use the
+            # :dataset option, where :allow_eager is not set, and no :eager_loader is
+            # provided, disallow eager loading.  In these cases, eager loading is
+            # unlikely to work.  This is not done for implicit setting of :instance_specific,
+            # because implicit use is done by default for all associations with blocks,
+            # and the vast majority of associations with blocks use the block for filtering
+            # in a manner compatible with eager loading.
+            opts[:allow_eager] = false
+          end
           opts = assoc_class.new.merge!(opts)
 
           if opts[:clone] && !opts.cloneable?(cloned_assoc)
@@ -2444,6 +2473,9 @@ module Sequel
         # Return dataset to graph into given the association reflection, applying the :callback option if set.
         def eager_graph_dataset(opts, eager_options)
           ds = opts.associated_class.dataset
+          if opts[:graph_use_association_block] && (b = opts[:block])
+            ds = b.call(ds)
+          end
           if cb = eager_options[:callback]
             ds = cb.call(ds)
           end
@@ -3355,8 +3387,15 @@ module Sequel
           local_opts = ds.opts[:eager_graph][:local]
           limit_strategy = r.eager_graph_limit_strategy(local_opts[:limit_strategy])
 
-          if r[:conditions] && !Sequel.condition_specifier?(r[:conditions]) && !r[:orig_opts].has_key?(:graph_conditions) && !r[:orig_opts].has_key?(:graph_only_conditions) && !r.has_key?(:graph_block)
-            raise Error, "Cannot eager_graph association when :conditions specified and not a hash or an array of pairs.  Specify :graph_conditions, :graph_only_conditions, or :graph_block for the association.  Model: #{r[:model]}, association: #{r[:name]}"
+          # SEQUEL6: remove and integrate the auto_restrict_eager_graph plugin
+          if !r[:orig_opts].has_key?(:graph_conditions) && !r[:orig_opts].has_key?(:graph_only_conditions) && !r.has_key?(:graph_block) && !r[:allow_eager_graph]
+            if r[:conditions] && !Sequel.condition_specifier?(r[:conditions])
+              raise Error, "Cannot eager_graph association when :conditions specified and not a hash or an array of pairs.  Specify :graph_conditions, :graph_only_conditions, or :graph_block for the association.  Model: #{r[:model]}, association: #{r[:name]}"
+            end
+
+            if r[:block] && !r[:graph_use_association_block]
+              warn "eager_graph used for association when association given a block without graph options.  The block is ignored in this case.  This will result in an exception starting in Sequel 6.  Model: #{r[:model]}, association: #{r[:name]}"
+            end
           end
 
           ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>join_type || local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
@@ -3535,11 +3574,11 @@ module Sequel
         end
 
         # Eagerly load all specified associations.
-        def eager_load(a, eager_assoc=@opts[:eager])
+        def eager_load(a, eager_assoc=@opts[:eager], m=model)
           return if a.empty?
 
           # Reflections for all associations to eager load
-          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
+          reflections = eager_assoc.keys.map{|assoc| m.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
 
           perform_eager_loads(prepare_eager_load(a, reflections, eager_assoc))