sequel 3.12.1 → 3.13.0

data/lib/sequel/extensions/schema_dumper.rb

@@ -118,7 +118,7 @@ END_MIG
     # database type is not recognized, return it as a String type.
     def column_schema_to_ruby_type(schema)
       case t = schema[:db_type].downcase
-      when /\A(?:medium|small)?int(?:eger)?(?:\((?:\d+)\))?\z/o
+      when /\A(?:medium|small)?int(?:eger)?(?:\((?:\d+)\))?(?: unsigned)?\z/o
         {:type=>Integer}
       when /\Atinyint(?:\((\d+)\))?\z/o
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}

data/lib/sequel/metaprogramming.rb

@@ -2,6 +2,10 @@ module Sequel
   # Contains meta_def method for adding methods to objects via blocks, used by some of Sequel's classes and objects.
   module Metaprogramming
     # Define a method with the given name and block body on the receiver.
+    #
+    #   ds = DB[:items]
+    #   ds.meta_def(:x){42}
+    #   ds.x # => 42
     def meta_def(name, &block)
       (class << self; self end).send(:define_method, name, &block)
     end

data/lib/sequel/model.rb

@@ -2,20 +2,38 @@ require 'sequel/core'
 
 module Sequel
   # Lets you create a Model subclass with its dataset already set.
-  # source can be an existing dataset or a symbol (in which case
-  # it will create a dataset using the default database with 
-  # the given symbol as the table name).
+  # +source+ should be an instance of one of the following classes:
   #
-  # The purpose of this method is to set the dataset automatically
+  # Database :: Sets the database for this model to +source+.
+  #             Generally only useful when subclassing directly
+  #             from the returned class, where the name of the
+  #             subclass sets the table name (which is combined
+  #             with the +Database+ in +source+ to create the
+  #             dataset to use) 
+  # Dataset :: Sets the dataset for this model to +source+. 
+  # Symbol :: Sets the table name for this model to +source+. The
+  #           class will use the default database for model
+  #           classes in order to create the dataset.
+  #
+  # The purpose of this method is to set the dataset/database automatically
   # for a model class, if the table name doesn't match the implicit
   # name.  This is neater than using set_dataset inside the class,
-  # doesn't require a bogus query for the schema, and allows
-  # it to work correctly in a system that uses code reloading.
+  # doesn't require a bogus query for the schema.
   #
-  # Example:
+  #   # Using a symbol
   #   class Comment < Sequel::Model(:something)
   #     table_name # => :something
   #   end
+  #
+  #   # Using a dataset
+  #   class Comment < Sequel::Model(DB1[:something])
+  #     dataset # => DB1[:something]
+  #   end
+  #
+  #   # Using a database
+  #   class Comment < Sequel::Model(DB1)
+  #     dataset # => DB1[:comments]
+  #   end
   def self.Model(source)
     Model::ANONYMOUS_MODEL_CLASSES[source] ||= if source.is_a?(Database)
       c = Class.new(Model)
@@ -26,20 +44,20 @@ module Sequel
     end
   end
 
-  # Sequel::Model is an object relational mapper built on top of Sequel core.  Each
+  # <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,
   # which have fairly standard ORM instance behavior.
   #
-  # Sequel::Model is built completely out of plugins, the only method not part of a
+  # <tt>Sequel::Model</tt> is built completely out of plugins, the only method not part of a
   # plugin is the plugin method itself.  Plugins can override any class, instance, or
   # dataset method defined by a previous plugin and call super to get the default
   # behavior.
   #
-  # You can set the SEQUEL_NO_ASSOCIATIONS constant or environment variable to
+  # You can set the +SEQUEL_NO_ASSOCIATIONS+ constant or environment variable to
   # make Sequel not load the associations plugin by default.
   class Model
-    # Map that stores model classes created with Sequel::Model(), to allow the reopening
+    # 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 = {}
 
@@ -54,24 +72,24 @@ module Sequel
     BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions]
 
     # Hooks that are called before an action.  Can return false to not do the action.  When
-    # overriding these, it is recommended to call super as the last line of your method,
+    # overriding these, it is recommended to call +super+ as the last line of your method,
     # so later hooks are called before earlier hooks.
     BEFORE_HOOKS = [:before_create, :before_update, :before_save, :before_destroy, :before_validation]
 
     # Hooks that are called after an action.  When overriding these, it is recommended to call
-    # super on the first line of your method, so later hooks are called before earlier hooks.
+    # +super+ on the first line of your method, so later hooks are called after earlier hooks.
     AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy, :after_validation]
 
     # Empty instance methods to create that the user can override to get hook/callback behavior.
     # Just like any other method defined by Sequel, if you override one of these, you should
-    # call super to get the default behavior (while empty by default, they can also be defined
+    # call +super+ to get the default behavior (while empty by default, they can also be defined
     # by plugins).  See the {"Model Hooks" guide}[link:files/doc/model_hooks_rdoc.html] for
     # more detail on hooks.
     HOOKS = BEFORE_HOOKS + AFTER_HOOKS
 
-    # Class instance variables that are inherited in subclasses.  If the value is :dup, dup is called
+    # Class instance variables that are inherited in subclasses.  If the value is <tt>:dup</tt>, dup is called
     # on the superclass's instance variable when creating the instance variable in the subclass.
-    # If the value is nil, the superclass's instance variable is used directly in the subclass.
+    # If the value is +nil+, the superclass's instance variable is used directly in the subclass.
     INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@dataset_methods=>:dup, 
       :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil,
       :@raise_on_save_failure=>nil, :@require_modification=>nil, 
@@ -80,8 +98,8 @@ module Sequel
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
       :@raise_on_typecast_failure=>nil, :@plugins=>:dup}
 
-    # Regexp that determines if a method name is normal in the sense that
-    # it could be called directly in ruby code without using send.  Used to
+    # Regular expression that determines if a method name is normal in the sense that
+    # it could be used literally in ruby code without using send.  Used to
     # avoid problems when using eval with a string to define methods.
     NORMAL_METHOD_NAME_REGEXP = /\A[A-Za-z_][A-Za-z0-9_]*\z/
 
@@ -116,7 +134,7 @@ module Sequel
     end
 
     # The setter methods (methods ending with =) that are never allowed
-    # to be called automatically via set/update/new/etc..
+    # to be called automatically via +set+/+update+/+new+/etc..
     RESTRICTED_SETTER_METHODS = instance_methods.map{|x| x.to_s}.grep(SETTER_METHOD_REGEXP)
   end
 end

data/lib/sequel/model/associations.rb

@@ -550,6 +550,8 @@ module Sequel
         #     columns in the associated table.
         #   - :limit - Limit the number of records to the provided value.  Use
         #     an array with two arguments for the value to specify a limit and an offset.
+        #   - :methods_module - The module that methods the association creates will be placed into. Defaults
+        #     to the module containing the model's columns.
         #   - :order - the column(s) by which to order the association dataset.  Can be a
         #     singular column or an array.
         #   - :order_eager_graph - Whether to add the order to the dataset's order when graphing
@@ -710,37 +712,43 @@ module Sequel
         
         private
       
+        # The module to use for the association's methods.  Defaults to
+        # the overridable_methods_module.
+        def association_module(opts={})
+          opts.fetch(:methods_module, overridable_methods_module)
+        end
+
         # Add a method to the module included in the class, so the method
         # can be easily overridden in the class itself while allowing for
         # super to be called.
-        def association_module_def(name, &block)
-          overridable_methods_module.module_eval{define_method(name, &block)}
+        def association_module_def(name, opts={}, &block)
+          association_module(opts).module_eval{define_method(name, &block)}
         end
       
         # Add a private method to the module included in the class.
-        def association_module_private_def(name, &block)
-          association_module_def(name, &block)
-          overridable_methods_module.send(:private, name)
+        def association_module_private_def(name, opts={}, &block)
+          association_module_def(name, opts, &block)
+          association_module(opts).send(:private, name)
         end
       
         # Add the add_ instance method 
         def def_add_method(opts)
-          association_module_def(opts.add_method){|o,*args| add_associated_object(opts, o, *args)}
+          association_module_def(opts.add_method, opts){|o,*args| add_associated_object(opts, o, *args)}
         end
       
         # Adds methods related to the association's dataset to the module included in the class.
         def def_association_dataset_methods(opts)
           # If a block is given, define a helper method for it, because it takes
           # an argument.  This is unnecessary in Ruby 1.9, as that has instance_exec.
-          association_module_private_def(opts.dataset_helper_method, &opts[:block]) if opts[:block]
-          association_module_private_def(opts._dataset_method, &opts[:dataset])
-          association_module_def(opts.dataset_method){_dataset(opts)}
+          association_module_private_def(opts.dataset_helper_method, opts, &opts[:block]) if opts[:block]
+          association_module_private_def(opts._dataset_method, opts, &opts[:dataset])
+          association_module_def(opts.dataset_method, opts){_dataset(opts)}
           def_association_method(opts)
         end
 
         # Adds method for retrieving the associated objects to the module included in the class.
         def def_association_method(opts)
-          association_module_def(opts.association_method){|*reload| load_associated_objects(opts, reload[0])}
+          association_module_def(opts.association_method, opts){|*reload| load_associated_objects(opts, reload[0])}
         end
       
         # Adds many_to_many association instance methods
@@ -770,7 +778,7 @@ module Sequel
             h = eo[:key_hash][left_pk]
             eo[:rows].each{|object| object.associations[name] = []}
             r = uses_rcks ? rcks.zip(opts.right_primary_keys) : [[right, opts.right_primary_key]]
-            l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, SQL::SQLArray.new(h.keys)]] : [[left, h.keys]]
+            l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, h.keys]] : [[left, h.keys]]
             model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), Array(opts.select), eo[:associations], eo).all do |assoc_record|
               hash_key = if uses_lcks
                 left_key_alias.map{|k| assoc_record.values.delete(k)}
@@ -801,16 +809,16 @@ module Sequel
       
           return if opts[:read_only]
       
-          association_module_private_def(opts._add_method) do |o|
+          association_module_private_def(opts._add_method, opts) do |o|
             h = {}
             lcks.zip(lcpks).each{|k, pk| h[k] = send(pk)}
             rcks.zip(opts.right_primary_keys).each{|k, pk| h[k] = o.send(pk)}
             _join_table_dataset(opts).insert(h)
           end
-          association_module_private_def(opts._remove_method) do |o|
+          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_keys.map{|k| o.send(k)})).delete
           end
-          association_module_private_def(opts._remove_all_method) do
+          association_module_private_def(opts._remove_all_method, opts) do
             _join_table_dataset(opts).filter(lcks.zip(lcpks.map{|k| send(k)})).delete
           end
       
@@ -841,7 +849,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(uses_cks ? {opts.primary_keys.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>SQL::SQLArray.new(keys)} : {SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>keys}), opts.select, eo[:associations], eo).all do |assoc_record|
+              model.eager_loading_dataset(opts, klass.filter(uses_cks ? {opts.primary_keys.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>keys} : {SQL::QualifiedIdentifier.new(klass.table_name, opts.primary_key)=>keys}), opts.select, eo[:associations], eo).all do |assoc_record|
                 hash_key = uses_cks ? opts.primary_keys.map{|k| assoc_record.send(k)} : assoc_record.send(opts.primary_key)
                 next unless objects = h[hash_key]
                 objects.each{|object| object.associations[name] = assoc_record}
@@ -863,8 +871,8 @@ module Sequel
           
           return if opts[:read_only]
       
-          association_module_private_def(opts._setter_method){|o| cks.zip(opts.primary_keys).each{|k, pk| send(:"#{k}=", (o.send(pk) if o))}}
-          association_module_def(opts.setter_method){|o| set_associated_object(opts, o)}
+          association_module_private_def(opts._setter_method, opts){|o| cks.zip(opts.primary_keys).each{|k, pk| send(:"#{k}=", (o.send(pk) if o))}}
+          association_module_def(opts.setter_method, opts){|o| set_associated_object(opts, o)}
         end
         
         # Adds one_to_many association instance methods
@@ -891,7 +899,7 @@ module Sequel
             end
             reciprocal = opts.reciprocal
             klass = opts.associated_class
-            model.eager_loading_dataset(opts, klass.filter(uses_cks ? {cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>SQL::SQLArray.new(h.keys)} : {SQL::QualifiedIdentifier.new(klass.table_name, key)=>h.keys}), opts.select, eo[:associations], eo).all do |assoc_record|
+            model.eager_loading_dataset(opts, klass.filter(uses_cks ? {cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>h.keys} : {SQL::QualifiedIdentifier.new(klass.table_name, key)=>h.keys}), opts.select, eo[:associations], eo).all do |assoc_record|
               hash_key = uses_cks ? cks.map{|k| assoc_record.send(k)} : assoc_record.send(key)
               next unless objects = h[hash_key]
               if one_to_one
@@ -931,7 +939,7 @@ module Sequel
             validate = opts[:validate]
 
             if one_to_one
-              association_module_private_def(opts._setter_method) do |o|
+              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)})))
                 if o
                   up_ds = up_ds.exclude(o.pk_hash)
@@ -942,19 +950,19 @@ module Sequel
                   o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save") if o
                 end
               end
-              association_module_def(opts.setter_method){|o| set_one_to_one_associated_object(opts, o)}
+              association_module_def(opts.setter_method, opts){|o| set_one_to_one_associated_object(opts, o)}
             else 
-              association_module_private_def(opts._add_method) do |o|
+              association_module_private_def(opts._add_method, opts) do |o|
                 cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
                 o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save")
               end
               def_add_method(opts)
       
-              association_module_private_def(opts._remove_method) do |o|
+              association_module_private_def(opts._remove_method, opts) do |o|
                 cks.each{|k| o.send(:"#{k}=", nil)}
                 o.save(:validate=>validate) || raise(Sequel::Error, "invalid associated object, cannot save")
               end
-              association_module_private_def(opts._remove_all_method) do
+              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)
               end
               def_remove_methods(opts)
@@ -969,8 +977,8 @@ module Sequel
         
         # Add the remove_ and remove_all instance methods
         def def_remove_methods(opts)
-          association_module_def(opts.remove_method){|o,*args| remove_associated_object(opts, o, *args)}
-          association_module_def(opts.remove_all_method){|*args| remove_all_associated_objects(opts, *args)}
+          association_module_def(opts.remove_method, opts){|o,*args| remove_associated_object(opts, o, *args)}
+          association_module_def(opts.remove_all_method, opts){|*args| remove_all_associated_objects(opts, *args)}
         end
       end
 

data/lib/sequel/model/base.rb

@@ -175,8 +175,8 @@ module Sequel
       
       # Like find but invokes create with given conditions when record does not
       # exist.
-      def find_or_create(cond)
-        find(cond) || create(cond)
+      def find_or_create(cond, &block)
+        find(cond) || create(cond, &block)
       end
     
       # If possible, set the dataset for the model subclass as soon as it

data/lib/sequel/model/plugins.rb

@@ -59,8 +59,13 @@ module Sequel
             Sequel::Plugins.const_get(module_name) == Sequel.const_get(module_name))
           begin
             Sequel.tsk_require "sequel/plugins/#{plugin}"
-          rescue LoadError
-            Sequel.tsk_require "sequel_#{plugin}"
+          rescue LoadError => e
+            begin
+              Sequel.tsk_require "sequel_#{plugin}"
+            rescue LoadError => e2
+              e.message << "; #{e2.message}"
+              raise e
+            end
           end
         end
         Sequel::Plugins.const_get(module_name)

data/lib/sequel/plugins/active_model.rb

@@ -1,7 +1,7 @@
 require 'active_model'
 module Sequel
   module Plugins
-    # The ActiveModel plugin makes Sequel::Model objects the
+    # The ActiveModel plugin makes Sequel::Model objects
     # pass the ActiveModel::Lint tests, which should
     # hopefully mean full ActiveModel compliance.  This should
     # allow the full support of Sequel::Model objects in Rails 3.

data/lib/sequel/plugins/association_pks.rb

@@ -39,13 +39,13 @@ module Sequel
 
         # Define a association_pks method using the block for the association reflection 
         def def_association_pks_getter(opts, &block)
-          association_module_def(:"#{singularize(opts[:name])}_pks", &block)
+          association_module_def(:"#{singularize(opts[:name])}_pks", opts, &block)
         end
 
         # Define a association_pks= method using the block for the association reflection,
         # if the association is not read only.
         def def_association_pks_setter(opts, &block)
-          association_module_def(:"#{singularize(opts[:name])}_pks=", &block) unless opts[:read_only]
+          association_module_def(:"#{singularize(opts[:name])}_pks=", opts, &block) unless opts[:read_only]
         end
 
         # Add a getter that checks the join table for matching records and

data/lib/sequel/plugins/association_proxies.rb

@@ -41,7 +41,7 @@ module Sequel
         # Changes the association method to return a proxy instead of the associated objects
         # directly.
         def def_association_method(opts)
-          opts.returns_array? ? association_module_def(opts.association_method){|*r| AssociationProxy.new(self, opts, r[0])} : super
+          opts.returns_array? ? association_module_def(opts.association_method, opts){|*r| AssociationProxy.new(self, opts, r[0])} : super
         end
       end
     end

data/lib/sequel/plugins/boolean_readers.rb

@@ -1,7 +1,7 @@
 module Sequel
   module Plugins
-    # The BooleaReaders plugin allows for the creation of attribute? methods
-    # for boolean columns, which provide a nicer API.  By default, the accessors
+    # The BooleanReaders plugin allows for the creation of attribute? methods
+    # for boolean columns, which provides a nicer API.  By default, the accessors
     # are created for all columns of type :boolean.  However, you can provide a
     # block to the plugin to change the criteria used to determine if a
     # column is boolean.  The block is yielded with the column symbol for each

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -89,7 +89,11 @@ module Sequel
           @cti_tables = [table_name]
           @cti_columns = {table_name=>columns}
           @cti_table_map = opts[:table_map] || {}
-          dataset.row_proc = lambda{|r| (m.call(r[key]) rescue model).load(r)}
+          dataset.row_proc = if key
+            lambda{|r| (m.call(r[key]) rescue model).load(r)}
+          else
+            lambda{|r| model.load(r)}
+          end
         end
       end
 
@@ -147,7 +151,11 @@ module Sequel
           super
           subclass.instance_eval do
             m = method(:constantize)
-            dataset.row_proc = lambda{|r| (m.call(r[ck]) rescue subclass).load(r)}
+            dataset.row_proc = if cti_key
+              lambda{|r| (m.call(r[ck]) rescue subclass).load(r)}
+            else
+              lambda{|r| subclass.load(r)}
+            end
             (columns - [cbm.primary_key]).each{|a| define_lazy_attribute_getter(a)}
             cti_tables.reverse.each do |table|
               db.schema(table).each{|k,v| db_schema[k] = v}

data/lib/sequel/plugins/identity_map.rb

@@ -10,17 +10,17 @@ module Sequel
     #     Album.filter{(id > 0) & (id < 2)}.first.object_id == Album.first(:id=>1).object_id
     #   end
     #
-    # In additional to providing a 1-1 correspondence, the identity_map plugin
+    # In addition to providing a 1-1 correspondence, the identity_map plugin
     # also provides a cached looked up of records in two cases:
     # * Model.[] (e.g. Album[1])
     # * Model.many_to_one accessor methods (e.g. album.artist)
     #
-    # If the object you are looking up using one of those two methods is already
+    # If the object you are looking up, using one of those two methods, is already
     # in the identity map, the record is returned without a database query being
     # issued.
     #
     # Identity maps are thread-local and only presist for the duration of the block,
-    # so they should be should only be considered as a possible performance enhancer.
+    # so they should only be considered as a possible performance enhancer.
     # 
     # Usage:
     #

data/lib/sequel/plugins/instance_hooks.rb

@@ -2,7 +2,7 @@ module Sequel
   module Plugins
     # The instance_hooks plugin allows you to add hooks to specific instances,
     # by passing a block to a _hook method (e.g. before_save_hook{do_something}).
-    # The block executed when the hook is called (e.g. before_save).
+    # The block is executed when the hook is called (e.g. before_save).
     #
     # All of the standard hooks are supported, except for after_initialize.
     # Instance level before hooks are executed in reverse order of addition before

data/lib/sequel/plugins/json_serializer.rb

@@ -0,0 +1,212 @@
+module Sequel
+  tsk_require 'json'
+
+  module Plugins
+    # The json_serializer plugin handles serializing entire Sequel::Model
+    # objects to JSON, as well as support for deserializing JSON directly
+    # into Sequel::Model objects.  It requires the json library, and can
+    # work with either the pure ruby version or the C extension.
+    #
+    # Basic Example:
+    #
+    #   album = Album[1]
+    #   album.to_json
+    #   # => '{"json_class"=>"Album","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])
+    #   # => '{"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"}}'
+    # 
+    # 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"}}'
+    #
+    # You can specify the <tt>:root</tt> option to nest the JSON under the
+    # name of the model:
+    #
+    #   album.to_json(:root => true)
+    #   # => '{"album":{"id":1,"name":"RF","artist_id":2}}'
+    #
+    # In addition to creating JSON, this plugin also enables Sequel::Model
+    # objects to be automatically created when JSON is parsed:
+    #
+    #   json = album.to_json
+    #   album = JSON.parse(json)
+    #
+    # In addition, you can update existing model objects directly from JSON
+    # using +from_json+:
+    #
+    #   album.from_json(json)
+    #
+    # This works by parsing the JSON (which should return a hash), and then
+    # calling +set+ with the returned hash.
+    #
+    # 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)
+    #
+    # Usage:
+    #
+    #   # Add JSON output capability to all model subclass instances (called before loading subclasses)
+    #   Sequel::Model.plugin :json_serializer
+    #
+    #   # Add JSON output capability to Album class instances
+    #   Album.plugin :json_serializer
+    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)
+        end
+      end
+      
+      # Helper class used for making sure that cascading options
+      # for model associations works correctly.  Cascaded options
+      # work by creating instances of this class, which take a
+      # literal JSON string and have +to_json+ return it.
+      class Literal
+        # Store the literal JSON to use
+        def initialize(json)
+          @json = json
+        end
+        
+        # Return the literal JSON to use
+        def to_json(*a)
+          @json
+        end
+      end
+
+      module ClassMethods
+        # The default opts to use when serializing model objects to JSON.
+        attr_reader :json_serializer_opts
+
+        # Create a new model object from the hash provided by parsing
+        # JSON.  Handles column values (stored in +values+), associations
+        # (stored in +associations+), and other values (by calling a
+        # setter method).  If an entry in the hash is not a column or
+        # an association, and no setter method exists, raises an Error.
+        def json_create(hash)
+          obj = new
+          cols = columns.map{|x| x.to_s}
+          assocs = associations.map{|x| x.to_s}
+          meths = obj.send(:setter_methods, nil, nil)
+          hash.delete(JSON.create_id)
+          hash.each do |k, v|
+            if assocs.include?(k)
+              obj.associations[k.to_sym] = v
+            elsif cols.include?(k)
+              obj.values[k.to_sym] = v
+            elsif meths.include?("#{k}=")
+              obj.send("#{k}=", v)
+            else
+              raise Error, "Entry in JSON hash not an association or column and no setter method exists: #{k}"
+            end
+          end
+          obj
+        end
+
+        # Call the dataset +to_json+ method.
+        def to_json(*a)
+          dataset.to_json(*a)
+        end
+        
+        # Copy the current model object's default json options into the subclass.
+        def inherited(subclass)
+          super
+          opts = {}
+          json_serializer_opts.each{|k, v| opts[k] = (v.is_a?(Array) || v.is_a?(Hash)) ? v.dup : v}
+          subclass.instance_variable_set(:@json_serializer_opts, opts)
+        end
+      end
+
+      module InstanceMethods
+        # Parse the provided JSON, which should return a hash,
+        # and call +set+ with that hash.
+        def from_json(json)
+          set(JSON.parse(json))
+        end
+
+        # Return a string in JSON format.  Accepts the following
+        # options:
+        #
+        # :except :: Symbol or Array of Symbols of columns not
+        #            to include in the JSON output.
+        # :include :: Symbol, Array of Symbols, or a Hash with
+        #             Symbol keys and Hash values specifying
+        #             associations or other non-column attributes
+        #             to include in the JSON output.  Using a nested
+        #             hash, you can pass options to associations
+        #             to affect the JSON used for associated objects.
+        # :naked :: Not to add the JSON.create_id key to the JSON
+        #           output hash, so when the JSON is parsed, it
+        #           will yield a hash instead of a model object.
+        # :only :: Symbol or Array of Symbols of columns to only
+        #          include in the JSON output, ignoring all other
+        #          columns.
+        # :root :: Qualify the JSON with the name of the object.
+        #          Implies :naked since the object name is explicit.
+        def to_json(*a)
+          if opts = a.first.is_a?(Hash)
+            opts = model.json_serializer_opts.merge(a.first)
+            a = []
+          else
+            opts = model.json_serializer_opts
+          end
+          vals = values
+          cols = if only = opts[:only]
+            Array(only)
+          else
+            vals.keys - Array(opts[:except])
+          end
+          h = (JSON.create_id && !opts[:naked] && !opts[:root]) ? {JSON.create_id=>model.name} : {}
+          cols.each{|c| h[c.to_s] = vals[c]}
+          if inc = opts[:include]
+            if inc.is_a?(Hash)
+              inc.each do |k, v|
+                v = v.empty? ? [] : [v]
+                h[k.to_s] = case objs = send(k)
+                when Array
+                  objs.map{|obj| Literal.new(obj.to_json(*v))}
+                else
+                  Literal.new(objs.to_json(*v))
+                end
+              end
+            else
+              Array(inc).each{|c| h[c.to_s] = send(c)}
+            end
+          end
+          h = {model.send(:underscore, model.to_s) => h} if opts[:root]
+          h.to_json(*a)
+        end
+      end
+
+      module DatasetMethods
+        # Return a JSON string representing an array of all objects in
+        # this dataset.  Takes the same options as the the instance
+        # method, and passes them to every instance.
+        def to_json(*a)
+          if opts = a.first.is_a?(Hash)
+            opts = model.json_serializer_opts.merge(a.first)
+            a = []
+          else
+            opts = model.json_serializer_opts
+          end
+          res = row_proc ? all.map{|obj| Literal.new(obj.to_json(opts))} : all
+          opts[:root] ? {model.send(:pluralize, model.send(:underscore, model.to_s)) => res}.to_json(*a) : res.to_json(*a)
+        end
+      end
+    end
+  end
+end