sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/insert_conflict.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The insert_conflict plugin allows handling conflicts due to unique
+    # constraints when saving new model instance, using the INSERT ON CONFLICT
+    # support in PostgreSQL 9.5+ and SQLite 3.24.0+. Example:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :insert_conflict
+    #   end
+    #
+    #   Album.new(name: 'Foo', copies_sold: 1000).
+    #     insert_conflict(
+    #       target: :name,
+    #       update: {copies_sold: Sequel[:excluded][:b]}
+    #     ).
+    #     save
+    #
+    # This example will try to insert the album, but if there is an existing
+    # album with the name 'Foo', this will update the copies_sold attribute
+    # for that album.  See the PostgreSQL and SQLite adapter documention for
+    # the options you can pass to the insert_conflict method.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support insert_conflict
+    #   Sequel::Model.plugin :insert_conflict
+    #
+    #   # Make the Album class support insert_conflict
+    #   Album.plugin :insert_conflict
+    module InsertConflict
+      def self.configure(model)
+        model.instance_exec do
+          if @dataset && !@dataset.respond_to?(:insert_conflict)
+            raise Error, "#{self}'s dataset does not support insert_conflict"
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Set the insert_conflict options to pass to the dataset when inserting. 
+        def insert_conflict(opts=OPTS)
+          raise Error, "Model#insert_conflict is only supported on new model instances" unless new?
+          @insert_conflict_opts = opts
+          self
+        end
+
+        private
+
+        # Set the dataset used for inserting to use INSERT ON CONFLICT
+        # Model#insert_conflict has been called on the instance previously.
+        def _insert_dataset
+          ds = super
+
+          if @insert_conflict_opts
+            ds = ds.insert_conflict(@insert_conflict_opts)
+          end
+
+          ds
+        end
+
+        # Disable the use of prepared insert statements, as they are not compatible
+        # with this plugin.
+        def use_prepared_statements_for?(type)
+          return false if type == :insert || type == :insert_select
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/insert_returning_select.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # If the model's dataset selects explicit columns and the
@@ -19,7 +21,7 @@ module Sequel
       # Modify the current model's dataset selection, if the model
       # has a dataset.
       def self.configure(model)
-        model.instance_eval do
+        model.instance_exec do
           self.dataset = dataset if @dataset && @dataset.opts[:select]
         end
       end
@@ -33,7 +35,7 @@ module Sequel
         # When reseting the instance dataset, also reset the instance_insert_dataset.
         def reset_instance_dataset
           ret = super
-          ds = @instance_dataset
+          return unless ds = @instance_dataset
 
           if columns = insert_returning_columns(ds)
             ds = ds.returning(*columns)

data/lib/sequel/plugins/instance_filters.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # This plugin allows you to add filters on a per object basis that
@@ -5,7 +7,9 @@ module Sequel
     # where you would normally have to drop down to the dataset level
     # to get the necessary control, because you only want to delete or
     # update the rows in certain cases based on the current status of
-    # the row in the database.
+    # the row in the database.  The main purpose of this plugin is to
+    # avoid race conditions by relying on the atomic properties of database
+    # transactions.
     # 
     #   class Item < Sequel::Model
     #     plugin :instance_filters
@@ -13,12 +17,12 @@ module Sequel
     #
     #   # These are two separate objects that represent the same
     #   # database row. 
-    #   i1 = Item.first(:id=>1, :delete_allowed=>false)
-    #   i2 = Item.first(:id=>1, :delete_allowed=>false)
+    #   i1 = Item.first(id: 1, delete_allowed: false)
+    #   i2 = Item.first(id: 1, delete_allowed: false)
     #
     #   # Add an instance filter to the object. This filter is in effect
     #   # until the object is successfully updated or deleted.
-    #   i1.instance_filter(:delete_allowed=>true)
+    #   i1.instance_filter(delete_allowed: true)
     #
     #   # Attempting to delete the object where the filter doesn't
     #   # match any rows raises an error.
@@ -26,7 +30,7 @@ module Sequel
     #
     #   # The other object that represents the same row has no
     #   # instance filters, and can be updated normally.
-    #   i2.update(:delete_allowed=>true)
+    #   i2.update(delete_allowed: true)
     #
     #   # Even though the filter is now still in effect, since the
     #   # database row has been updated to allow deleting,
@@ -98,7 +102,7 @@ module Sequel
         
         # Apply the instance filters to the given dataset
         def apply_instance_filters(ds)
-          instance_filters.inject(ds){|ds1, i| ds1.filter(*i[0], &i[1])}
+          instance_filters.inject(ds){|ds1, i| ds1.where(*i[0], &i[1])}
         end
         
         # Clear the instance filters.
@@ -119,10 +123,10 @@ module Sequel
         # Only use prepared statements for update and delete queries
         # if there are no instance filters.
         def use_prepared_statements_for?(type)
-          if (type == :update || type == :delete) && !instance_filters.empty?
+          if type == :update && !instance_filters.empty?
             false
           else
-            super
+            super if defined?(super)
           end
         end
       end

data/lib/sequel/plugins/instance_hooks.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The instance_hooks plugin allows you to add hooks to specific instances,
@@ -7,8 +9,7 @@ module Sequel
     # All of the standard hooks are supported.
     # Instance level before hooks are executed in reverse order of addition before
     # calling super.  Instance level after hooks are executed in order of addition
-    # after calling super.  If any of the instance level before hook blocks return
-    # false, no more instance level before hooks are called and false is returned.
+    # after calling super.
     #
     # Instance level hooks for before and after are cleared after all related
     # after level instance hooks have run.  This means that if you add a before_create
@@ -28,10 +29,7 @@ module Sequel
     #   Album.plugin :instance_hooks
     module InstanceHooks
       module InstanceMethods 
-        BEFORE_HOOKS = Sequel::Model::BEFORE_HOOKS
-        AFTER_HOOKS = Sequel::Model::AFTER_HOOKS
-        HOOKS = BEFORE_HOOKS + AFTER_HOOKS
-        HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
+        Sequel::Model::HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
           def #{h}_hook(&block)
             raise Sequel::Error, "can't add hooks to frozen object" if frozen?
             add_instance_hook(:#{h}, &block)
@@ -39,31 +37,57 @@ module Sequel
           end
         END
         
-        BEFORE_HOOKS.each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) == false ? false : super end", __FILE__, __LINE__)}
-        (AFTER_HOOKS - [:after_validation, :after_save]).each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
+        [:before_create, :before_update, :before_validation].each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) if @instance_hooks; super end", __FILE__, __LINE__)}
+        [:after_create, :after_update].each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
           def #{h}
             super
+            return unless @instance_hooks
             run_after_instance_hooks(:#{h})
             @instance_hooks.delete(:#{h})
             @instance_hooks.delete(:#{h.to_s.sub('after', 'before')})
           end
         END
 
-        # Run after validation hooks, without clearing the validation hooks.
+        # Run after destroy instance hooks.
+        def after_destroy
+          super
+          return unless @instance_hooks
+          run_after_instance_hooks(:after_destroy)
+          @instance_hooks.delete(:after_destroy)
+          @instance_hooks.delete(:before_destroy)
+        end
+
+        # Run after validation instance hooks.
         def after_validation
           super
+          return unless @instance_hooks
           run_after_instance_hooks(:after_validation)
         end
         
-        # Run after save hooks, clearing both the save and validation hooks.
+        # Run after save instance hooks.
         def after_save
           super
+          return unless @instance_hooks
           run_after_instance_hooks(:after_save)
           @instance_hooks.delete(:after_save)
           @instance_hooks.delete(:before_save)
           @instance_hooks.delete(:after_validation)
           @instance_hooks.delete(:before_validation)
         end
+
+        # Run before_destroy instance hooks.
+        def before_destroy
+          return super unless @instance_hooks
+          run_before_instance_hooks(:before_destroy)
+          super
+        end
+
+        # Run before_save instance hooks.
+        def before_save
+          return super unless @instance_hooks
+          run_before_instance_hooks(:before_save)
+          super
+        end
         
         private
         
@@ -71,7 +95,7 @@ module Sequel
         # the beginning of the instance hook's array.  For after hooks, add it
         # to the end.
         def add_instance_hook(hook, &block)
-          instance_hooks(hook).send(BEFORE_HOOKS.include?(hook) ? :unshift : :push, block)
+          instance_hooks(hook).public_send(hook.to_s.start_with?('before') ? :unshift : :push, block)
         end
         
         # An array of instance level hook blocks for the given hook type.
@@ -84,12 +108,7 @@ module Sequel
         def run_after_instance_hooks(hook)
           instance_hooks(hook).each(&:call)
         end
-
-        # Run all hook blocks of the given hook type.  If a hook block returns false,
-        # immediately return false without running the remaining blocks.
-        def run_before_instance_hooks(hook)
-          instance_hooks(hook).each{|b| return false if b.call == false}
-        end
+        alias run_before_instance_hooks run_after_instance_hooks
       end
     end
   end

data/lib/sequel/plugins/instance_specific_default.rb

@@ -0,0 +1,113 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The instance_specific_default plugin exists to make it easier to use a
+    # global :instance_specific association option, or to warn or raise when Sequel
+    # has to guess which value to use :instance_specific option (Sequel defaults to
+    # guessing true as that is the conservative setting).  It is helpful to
+    # use this plugin, particularly with the :warn or :raise settings, to determine
+    # which associations should have :instance_specific set.  Setting the
+    # :instance_specific to false for associations that are not instance specific
+    # can improve performance.
+    #
+    # Associations are instance-specific if their block calls
+    # a model instance method, or where the value of the block varies
+    # based on runtime state, and the variance is outside of a delayed evaluation.
+    # For example, with the following three associations:
+    #
+    #   Album.one_to_one :first_track, class: :Track do |ds|
+    #     ds.where(number: 1)
+    #   end
+    #
+    #   Album.one_to_one :last_track, class: :Track do |ds|
+    #     ds.where(number: num_tracks)
+    #   end
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track do |ds|
+    #     ds.where{date_updated > Date.today - 10}
+    #   end
+    #
+    # +first_track+ is not instance specific, but +last_track+ and +recent_tracks+ are.
+    # +last_trac+ is because the +num_tracks+ call in the block is calling
+    # <tt>Album#num_tracks</tt>.  +recent_tracks+ is because the value will change over
+    # time. This plugin allows you to find these cases, and set the :instance_specific
+    # option appropriately for them:
+    #
+    #   Album.one_to_one :first_track, class: :Track, instance_specific: false do |ds|
+    #     ds.where(number: 1)
+    #   end
+    #
+    #   Album.one_to_one :last_track, class: :Track, instance_specific: true do |ds|
+    #     ds.where(number: num_tracks)
+    #   end
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track, instance_specific: true do |ds|
+    #     ds.where{date_updated > Date.today - 10}
+    #   end
+    #
+    # For the +recent_tracks+ association, instead of marking it instance_specific, you
+    # could also use a delayed evaluation, since it doesn't actually contain
+    # instance-specific code:
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track, instance_specific: false do |ds|
+    #     ds.where{date_updated > Sequel.delay{Date.today - 10}}
+    #   end
+    #
+    # Possible arguments to provide when loading the plugin:
+    #
+    # true :: Set the :instance_specific option to true
+    # false :: Set the :instance_specific option to false
+    # :default :: Call super to set the :instance_specific option
+    # :warn :: Emit a warning before calling super to set the :instance_specific option
+    # :raise :: Raise a Sequel::Error if an :instance_specific option is not provided and
+    #           an association could be instance-specific.
+    #
+    # Note that this plugin only affects associations which could be instance
+    # specific (those with blocks), where the :instance_specific option was not
+    # specified when the association was created.
+    #
+    # Usage:
+    #
+    #   # Set how to handle associations that could be instance specific
+    #   # but did not specify an :instance_specific option, for all subclasses
+    #   # (set before creating subclasses).
+    #   Sequel::Model.plugin :instance_specific_default, :warn
+    #
+    #   # Set how to handle associations that could be instance specific
+    #   # but did not specify an :instance_specific option, for the Album class
+    #   Album.plugin :instance_specific_default, :warn
+    module InstanceSpecificDefault
+      # Set how to handle associations that could be instance specific but did
+      # not specify an :instance_specific value.
+      def self.configure(model, default)
+        model.instance_variable_set(:@instance_specific_default, default)
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@instance_specific_default=>nil)
+
+        private
+
+        # Return the appropriate :instance_specific value, or warn or raise if
+        # configured.
+        def _association_instance_specific_default(name)
+          case @instance_specific_default
+          when true, false
+            return @instance_specific_default
+          when :default
+            # nothing
+          when :warn
+            warn("possibly instance-specific association without :instance_specific option (class: #{self}, association: #{name})", :uplevel => 3)
+          when :raise
+            raise Sequel::Error, "possibly instance-specific association without :instance_specific option (class: #{self}, association: #{name})"
+          else
+            raise Sequel::Error, "invalid value passed to instance_specific_default plugin: #{@instance_specific_default.inspect}"
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/inverted_subsets.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The inverted_subsets plugin adds another method for each defined
@@ -16,7 +18,9 @@ module Sequel
     #   Album.plugin :inverted_subsets
     #
     #   # This will now create two methods, published and not_published
-    #   Album.subset :published, :published => true
+    #   Album.dataset_module do
+    #     where :published, published: true
+    #   end
     #
     #   Album.published.sql
     #   # SELECT * FROM albums WHERE (published IS TRUE)
@@ -25,22 +29,29 @@ module Sequel
     #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
     #
     module InvertedSubsets
-      # Default naming for inverted subsets
-      DEFAULT_NAME_BLOCK = lambda{|name| "not_#{name}"}
-
-      # Store the supplied block for calling later when subsets are defined, or
-      # create a default one if we need to.
-      def self.configure(model, &block)
-        model.instance_variable_set(:@inverted_subsets_name_block, block || DEFAULT_NAME_BLOCK)
+      def self.apply(model, &block)
+        model.instance_exec do
+          @dataset_module_class = Class.new(@dataset_module_class) do
+            include DatasetModuleMethods
+            if block
+              define_method(:inverted_subset_name, &block)
+              private :inverted_subset_name
+            end
+          end
+        end
       end
 
-      module ClassMethods
-        Plugins.inherited_instance_variables(self, :@inverted_subsets_name_block => nil)
-
+      module DatasetModuleMethods
         # Define a not_ prefixed subset which inverts the subset condition.
-        def subset(name, *args, &block)
+        def where(name, *args, &block)
           super
-          def_dataset_method(@inverted_subsets_name_block.call(name)){exclude(*args, &block)}
+          exclude(inverted_subset_name(name), *args, &block)
+        end
+
+        private
+
+        def inverted_subset_name(name)
+          "not_#{name}"
         end
       end
     end

data/lib/sequel/plugins/json_serializer.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 require 'json'
 
 module Sequel
@@ -11,41 +13,59 @@ module Sequel
     #
     #   album = Album[1]
     #   album.to_json
-    #   # => '{"json_class"=>"Album","id"=>1,"name"=>"RF","artist_id"=>2}'
+    #   # => '{"id"=>1,"name"=>"RF","artist_id"=>2}'
     #
     # In addition, you can provide options to control the JSON output:
     #
-    #   album.to_json(:only=>:name)
-    #   album.to_json(:except=>[:id, :artist_id])
+    #   album.to_json(only: :name)
+    #   album.to_json(except: [:id, :artist_id])
     #   # => '{"json_class"="Album","name"=>"RF"}'
     #   
-    #   album.to_json(:include=>:artist)
-    #   # => '{"json_class":"Album","id":1,"name":"RF","artist_id":2,
-    #   #      "artist":{"json_class":"Artist","id":2,"name":"YJM"}}'
+    #   album.to_json(include: :artist)
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "artist":{"id":2,"name":"YJM"}}'
     # 
     # You can use a hash value with <tt>:include</tt> to pass options
     # to associations:
     #
-    #   album.to_json(:include=>{:artist=>{:only=>:name}})
-    #   # => '{"json_class":"Album","id":1,"name":"RF","artist_id":2,
-    #   #      "artist":{"json_class":"Artist","name":"YJM"}}'
+    #   album.to_json(include: {artist: {only: :name}})
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "artist":{"name":"YJM"}}'
+    #
+    # You can specify a name for a given association by using an aliased
+    # expression as the key in the <tt>:include</tt> hash
     #
+    #   album.to_json(include: {Sequel.as(:artist, :singer)=>{only: :name}})
+    #   # => '{"id":1,"name":"RF","artist_id":2,
+    #   #      "singer":{"name":"YJM"}}'
+    # 
     # You can specify the <tt>:root</tt> option to nest the JSON under the
     # name of the model:
     #
-    #   album.to_json(:root => true)
+    #   album.to_json(root: true)
     #   # => '{"album":{"id":1,"name":"RF","artist_id":2}}'
     #
+    # You can specify JSON serialization options to use later:
+    #
+    #   album.json_serializer_opts(root: true)
+    #   [album].to_json
+    #   # => '[{"album":{"id":1,"name":"RF","artist_id":2}}]'
+    #
     # Additionally, +to_json+ also exists as a class and dataset method, both
     # of which return all objects in the dataset:
     #
     #   Album.to_json
-    #   Album.filter(:artist_id=>1).to_json(:include=>:tags)
+    #   Album.where(artist_id: 1).to_json(include: :tags)
     #
     # If you have an existing array of model instances you want to convert to
     # JSON, you can call the class to_json method with the :array option:
     #
-    #   Album.to_json(:array=>[Album[1], Album[2]])
+    #   Album.to_json(array: [Album[1], Album[2]])
+    #
+    # All to_json methods take blocks, and if a block is given, it will yield
+    # the array or hash before serialization, and will serialize the value
+    # the block returns.  This allows you to customize the resulting JSON format
+    # on a per-call basis.
     #
     # In addition to creating JSON, this plugin also enables Sequel::Model
     # classes to create instances directly from JSON using the from_json class
@@ -57,7 +77,7 @@ module Sequel
     # The array_from_json class method exists to parse arrays of model instances
     # from json:
     #
-    #   json = Album.filter(:artist_id=>1).to_json
+    #   json = Album.where(artist_id: 1).to_json
     #   albums = Album.array_from_json(json)
     #
     # These does not necessarily round trip, since doing so would let users
@@ -66,7 +86,7 @@ module Sequel
     # fields, you can use the :fields option, which will call set_fields with
     # the given fields:
     #
-    #   Album.from_json(album.to_json, :fields=>%w'id name')
+    #   Album.from_json(album.to_json, fields: %w'id name')
     #
     # If you want to update an existing instance, you can use the from_json
     # instance method:
@@ -76,27 +96,23 @@ module Sequel
     # Both of these allow creation of cached associated objects, if you provide
     # the :associations option:
     #
-    #   album.from_json(json, :associations=>:artist)
+    #   album.from_json(json, associations: :artist)
     #
     # You can even provide options when setting up the associated objects:
     #
-    #   album.from_json(json, :associations=>{:artist=>{:fields=>%w'id name', :associations=>:tags}})
+    #   album.from_json(json, associations: {artist: {fields: %w'id name', associations: :tags}})
     #
     # Note that active_support/json makes incompatible changes to the to_json API,
     # and breaks some aspects of the json_serializer plugin.  You can undo the damage
     # done by active_support/json by doing:
     #
-    #   class Array
-    #     def to_json(options = {})
-    #       JSON.generate(self)
-    #     end
-    #   end
-    #
-    #   class Hash
+    #   module ActiveSupportBrokenJSONFix
     #     def to_json(options = {})
     #       JSON.generate(self)
     #     end
     #   end
+    #   Array.send(:prepend, ActiveSupportBrokenJSONFix)
+    #   Hash.send(:prepend, ActiveSupportBrokenJSONFix)
     #
     # Note that this will probably cause active_support/json to no longer work
     # correctly in some cases.
@@ -111,9 +127,9 @@ module Sequel
     module JsonSerializer
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
-      def self.configure(model, opts={})
-        model.instance_eval do
-          @json_serializer_opts = (@json_serializer_opts || {}).merge(opts)
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          @json_serializer_opts = (@json_serializer_opts || OPTS).merge(opts)
         end
       end
       
@@ -137,6 +153,15 @@ module Sequel
         # The default opts to use when serializing model objects to JSON.
         attr_reader :json_serializer_opts
 
+        # Freeze json serializier opts when freezing model class
+        def freeze
+          @json_serializer_opts.freeze.each_value do |v|
+            v.freeze if v.is_a?(Array) || v.is_a?(Hash)
+          end
+
+          super
+        end
+
         # Attempt to parse a single instance from the given JSON string,
         # with options passed to InstanceMethods#from_json_node.
         def from_json(json, opts=OPTS)
@@ -198,10 +223,10 @@ module Sequel
           if assocs = opts[:associations]
             assocs = case assocs
             when Symbol
-              {assocs=>{}}
+              {assocs=>OPTS}
             when Array
               assocs_tmp = {}
-              assocs.each{|v| assocs_tmp[v] = {}}
+              assocs.each{|v| assocs_tmp[v] = OPTS}
               assocs_tmp
             when Hash
               assocs
@@ -239,6 +264,20 @@ module Sequel
           self
         end
 
+        # Set the json serialization options that will be used by default
+        # in future calls to +to_json+.  This is designed for cases where
+        # the model object will be used inside another data structure
+        # which to_json is called on, and as such will not allow passing
+        # of arguments to +to_json+.
+        #
+        # Example:
+        #
+        #   obj.json_serializer_opts(only: :name)
+        #   [obj].to_json # => '[{"name":"..."}]'
+        def json_serializer_opts(opts=OPTS)
+          @json_serializer_opts = (@json_serializer_opts||OPTS).merge(opts)
+        end
+
         # Return a string in JSON format.  Accepts the following
         # options:
         #
@@ -257,12 +296,13 @@ module Sequel
         #          string is given, use the string as the key, otherwise
         #          use an underscored version of the model's name.
         def to_json(*a)
-          if opts = a.first.is_a?(Hash)
-            opts = model.json_serializer_opts.merge(a.first)
+          opts = model.json_serializer_opts
+          opts = opts.merge(@json_serializer_opts) if @json_serializer_opts
+          if (arg_opts = a.first).is_a?(Hash)
+            opts = opts.merge(arg_opts)
             a = []
-          else
-            opts = model.json_serializer_opts
           end
+
           vals = values
           cols = if only = opts[:only]
             Array(only)
@@ -276,16 +316,39 @@ module Sequel
           if inc = opts[:include]
             if inc.is_a?(Hash)
               inc.each do |k, v|
+                if k.is_a?(Sequel::SQL::AliasedExpression)
+                  key_name = k.alias.to_s
+                  k = k.expression
+                else
+                  key_name = k.to_s
+                end
+
                 v = v.empty? ? [] : [v]
-                h[k.to_s] = case objs = send(k)
-                when Array
+
+                objs = public_send(k)
+
+                is_array = if r = model.association_reflection(k)
+                  r.returns_array?
+                else
+                  objs.is_a?(Array)
+                end
+                
+                h[key_name] = if is_array
                   objs.map{|obj| Literal.new(Sequel.object_to_json(obj, *v))}
                 else
                   Literal.new(Sequel.object_to_json(objs, *v))
                 end
               end
             else
-              Array(inc).each{|c| h[c.to_s] = send(c)}
+              Array(inc).each do |c|
+                if c.is_a?(Sequel::SQL::AliasedExpression)
+                  key_name = c.alias.to_s
+                  c = c.expression
+                else
+                  key_name = c.to_s
+                end
+                h[key_name] = public_send(c)
+              end
             end
           end
 
@@ -296,11 +359,19 @@ module Sequel
             h = {root => h}
           end
 
+          h = yield h if block_given?
           Sequel.object_to_json(h, *a)
         end
       end
 
       module DatasetMethods
+        # Store default options used when calling to_json on this dataset.
+        # These options take precedence over the class level options,
+        # and can be overridden by passing options directly to to_json.
+        def json_serializer_opts(opts=OPTS)
+          clone(:json_serializer_opts=>opts)
+        end
+
         # Return a JSON string representing an array of all objects in
         # this dataset.  Takes the same options as the instance
         # method, and passes them to every instance.  Additionally,
@@ -308,6 +379,8 @@ module Sequel
         #
         # :array :: An array of instances.  If this is not provided,
         #           calls #all on the receiver to get the array.
+        # :instance_block :: A block to pass to #to_json for each
+        #                    value in the dataset (or :array option).
         # :root :: If set to :collection, wraps the collection
         #          in a root object using the pluralized, underscored model
         #          name as the key.  If set to :instance, only wraps
@@ -316,11 +389,15 @@ module Sequel
         #          object.  If set to a string, wraps the collection in
         #          a root object using the string as the key.  
         def to_json(*a)
-          if opts = a.first.is_a?(Hash)
-            opts = model.json_serializer_opts.merge(a.first)
+          opts = model.json_serializer_opts
+
+          if ds_opts = @opts[:json_serializer_opts]
+            opts = opts.merge(ds_opts)
+          end
+
+          if (arg = a.first).is_a?(Hash)
+            opts = opts.merge(arg)
             a = []
-          else
-            opts = model.json_serializer_opts
           end
 
           case collection_root = opts[:root]
@@ -336,23 +413,22 @@ module Sequel
             end
           end
 
-          res = if row_proc 
+          res = if row_proc || @opts[:eager_graph] 
             array = if opts[:array]
               opts = opts.dup
               opts.delete(:array)
             else
               all
             end
-            array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts))}
-           else
+            array.map{|obj| Literal.new(Sequel.object_to_json(obj, opts, &opts[:instance_block]))}
+          else
             all
           end
 
-          if collection_root
-            Sequel.object_to_json({collection_root => res}, *a)
-          else
-            Sequel.object_to_json(res, *a)
-          end
+          res = {collection_root => res} if collection_root
+          res = yield res if block_given?
+
+          Sequel.object_to_json(res, *a)
         end
       end
     end