sequel 3.36.1 → 3.37.0

data/CHANGELOG

@@ -1,3 +1,87 @@
+=== 3.37.0 (2012-07-02)
+
+* Allow specifying eager_graph alias base on a per-call basis using an AliasedExpression (jeremyevans)
+
+* Allow bin/sequel to respect multiple -l options for logging to multiple files (jeremyevans)
+
+* Correctly handle cases where SCOPE_IDENTITY is nil in the odbc/mssql adapter (stnoonan, jeremyevans)
+
+* Add pg_interval extension, for returning interval types as ActiveSupport::Duration instances (jeremyevans)
+
+* Save a new one_to_one associated object once instead of twice in the nested_attributes plugin (jeremyevans)
+
+* Don't add unnecessary filter condition when passing a new object to a one_to_one setter method (jeremyevans)
+
+* Differentiate between column references and method references in many_through_many associations (jeremyevans)
+
+* Use :qualify=>:deep option when joining tables in model association datasets (jeremyevans)
+
+* Support :qualify=>:deep option to Dataset#join_table to qualify subexpressions in the expression tree (jeremyevans)
+
+* Support :qualify=>false option to Dataset#join_table to not automatically qualify keys/values (jeremyevans)
+
+* Make filter by associations support use column references and method references correctly (jeremyevans)
+
+* Call super in list plugin before_create (jeremyevans) (#504)
+
+* Do not automatically cast String to text in pg_auto_parameterize extension (jeremyevans)
+
+* Support alter_table validate_constraint on PostgreSQL for validating constraints previously declared with NOT VALID (jeremyevans)
+
+* Support :not_valid option when adding foreign key constraints on PostgreSQL (jeremyevans)
+
+* Support exclusion constraints on PostgreSQL (jeremyevans)
+
+* Allow for overriding the create/alter table generators used per Database object (jeremyevans)
+
+* Make casting to Date/(Time/DateTime) use date/datetime functions on SQLite (jeremyevans)
+
+* Add pg_range_ops extension for DSL support for PostgreSQL range operators and functions (jeremyevans)
+
+* The json library is now required when running the plugin/extension specs (jeremyevans)
+
+* Use change migrations instead of up/down migrations in the schema_dumper (jeremyevans)
+
+* Dump unsigned integer columns with a check >= 0 constraint in the schema_dumper (stu314)
+
+* Switch the :key_hash entry to the association :eager_loader option to use the method symbol(s) instead of the column symbol(s) (jeremyevans)
+
+* Add :id_map entry to the hash passed to the association :eager_loader option, for easier custom eager loading (jeremyevans)
+
+* Fix dumping of non-integer foreign key columns in the schema_dumper (jeremyevans) (#502)
+
+* Add nested_attributes :fields option to be a proc that is called with the associated object (chanks) (#498)
+
+* Add split_array_nil extension, for compiling :col=>[1, nil] to col IN (1) OR col IS NULL (jeremyevans)
+
+* Add Database#extension and Dataset#extension for loading extension modules into objects automatically (jeremyevans)
+
+* Respect an existing dataset limit when updating on Microsoft SQL Server (jeremyevans)
+
+* Add pg_range extension, for dealing with PostgreSQL 9.2+ range types (jeremyevans)
+
+* Make pg_array extension convert array members when typecasting Array to PGArray (jeremyevans)
+
+* Make jdbc/postgres adapter convert array type elements (e.g. date[] arrays are returned as arrays of Date instances) (jeremyevans)
+
+* Make the pg_inet extension handle inet[]/cidr[]/macaddr[] types when used with the pg_array extension (jeremyevans)
+
+* Make the pg_json extension handle json[] type when used with the pg_array extension (jeremyevans)
+
+* Fix schema parsing of h2 clob types (jeremyevans)
+
+* Make the pg_array extension handle array types for scalar types handled by the native postgres adapter (jeremyevans)
+
+* Generalize handling of array types in the pg_array extension, allowing easy support of custom array types (jeremyevans)
+
+* Remove type conversion of int2vector and money types on PostgreSQL, since previous conversions were wrong (jeremyevans)
+
+* Add eval_inspect extension, which makes Sequel::SQL::Expression#inspect attempt to return a string suitable for eval (jeremyevans)
+
+* When emulating offset with ROW_NUMBER, default to ordering by all columns if no specific order is given (stnoonan, jeremyevans) (#490)
+
+* Work around JRuby 1.6 ruby 1.9 mode bug in Time -> SQLTime conversion (jeremyevans)
+
 === 3.36.1 (2012-06-01)
 
 * Fix jdbc adapter when DriverManager#getConnection fails (aportnov) (#488)

data/Rakefile

@@ -138,6 +138,19 @@ begin
   %w'postgres sqlite mysql informix oracle firebird mssql db2'.each do |adapter|
     spec_with_cov.call("spec_#{adapter}", ["spec/adapters/#{adapter}_spec.rb"] + Dir["spec/integration/*_test.rb"], "Run #{adapter} specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|connection_pool|database|dataset|model|extensions|plugins)"')}
   end
+  
+  task :spec_travis=>[:spec, :spec_plugin, :spec_sqlite] do
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+      ENV['SEQUEL_PG_SPEC_DB'] = "jdbc:postgresql://localhost/sequel_test?user=postgres"
+      ENV['SEQUEL_MY_SPEC_DB'] = "jdbc:mysql://localhost/sequel_test?user=root"
+    else
+      ENV['SEQUEL_PG_SPEC_DB'] = "postgres://localhost/sequel_test?user=postgres"
+      ENV['SEQUEL_MY_SPEC_DB'] = "mysql2://localhost/sequel_test?user=root"
+    end
+
+    Rake::Task['spec_postgres'].invoke
+    Rake::Task['spec_mysql'].invoke
+  end
 
   desc "Run model specs without the associations code"
   task :spec_model_no_assoc do

data/bin/sequel

@@ -4,18 +4,17 @@ require 'rubygems'
 require 'optparse'
 require 'sequel'
 
-db_opts = {:test=>true}
 copy_databases = nil
 dump_migration = nil
 dump_schema = nil
-echo = nil
 env = nil
-logfile = nil
 migrate_dir = nil
 migrate_ver = nil
 backtrace = nil
+test = true
 load_dirs = []
 exclusive_options = []
+loggers = []
 
 opts = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
@@ -54,7 +53,8 @@ opts = OptionParser.new do |opts|
   end
   
   opts.on("-E", "--echo", "echo SQL statements") do
-    echo = true
+    require 'logger'
+    loggers << Logger.new($stdout)
   end
   
   opts.on("-I", "--include dir", "specify $LOAD_PATH directory") do |v|
@@ -62,7 +62,8 @@ opts = OptionParser.new do |opts|
   end
 
   opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
-    logfile = v
+    require 'logger'
+    loggers << Logger.new(v)
   end
   
   opts.on("-L", "--load-dir DIR", "loads all *.rb under specifed directory") do |v|
@@ -79,7 +80,7 @@ opts = OptionParser.new do |opts|
   end
 
   opts.on("-N", "--no-test-connection", "do not test the connection") do
-    db_opts[:test] = false
+    test = false
   end
 
   opts.on("-r", "--require lib", "require the library, before executing your script") do |v|
@@ -112,26 +113,21 @@ end
 error_proc["Error: Must specify -m if using -M"] if migrate_ver && !migrate_dir
 error_proc["Error: Cannot specify #{exclusive_options.map{|v| "-#{v}"}.join(' and ')} together"] if exclusive_options.length > 1
 
-if logfile || echo
-  require 'logger'
-  db_opts[:loggers] = []
-  db_opts[:loggers] << Logger.new(logfile) if logfile
-  db_opts[:loggers] << Logger.new($stdout) if echo
-end
-
 connect_proc = lambda do |database|
   db = if database.nil? || database.empty?
-    Sequel.connect('mock:///', db_opts)
+    Sequel.connect('mock:///')
   elsif File.exist?(database)
     require 'yaml'
     env ||= "development"
     db_config = YAML.load_file(database)
     db_config = db_config[env] || db_config[env.to_sym] || db_config
     db_config.keys.each{|k| db_config[k.to_sym] = db_config.delete(k)}
-    Sequel.connect(db_config.merge!(db_opts))
+    Sequel.connect(db_config)
   else
-    Sequel.connect(database, db_opts)
+    Sequel.connect(database)
   end
+  db.loggers = loggers
+  db.test_connection if test
   db
 end
 

data/doc/advanced_associations.rdoc

@@ -75,19 +75,15 @@ option.  Though it can often be verbose (compared to other things in Sequel),
 it allows you complete control over how to eagerly load associations for a
 group of objects.
 
-:eager_loader should be a proc that takes 1 or 3 arguments.  If the proc
-takes one argument, it will be given a hash with the following keys:
+:eager_loader should be a proc that takes a single hash argument, which will
+have at least the following keys:
 
-:key_hash :: A key_hash, described below
+:id_map :: A mapping of key values to arrays of current model instances,
+           usage described below
 :rows :: An array of model objects
 :associations :: A hash of dependent associations to eagerly load
 :self :: The dataset that is doing the eager loading
-
-If the proc takes three arguments, it gets passed the :key_hash, :rows,
-and :associations values.  The only way to get the :self value is to
-accept one argument.  The 3 argument procs are allowed for backwards
-compatibility, and it is recommended to use the 1 argument proc format
-for new code.
+:eager_block :: A dynamic callback for this eager load.
 
 Since you are given all of the records, you can do things like filter on
 associations that are specified by multiple keys, or do multiple
@@ -98,13 +94,12 @@ associations cache for all objects in the array of records.  The hash
 of dependent associations is available for you to cascade the eager
 loading down multiple levels, but it is up to you to use it.
 
-The key_hash is a performance enhancement that is used by the default
-association loaders and is also available to you.  It is a hash with keys being
-foreign/primary key symbols in the current table, and the values
-being hashes where the key is foreign/primary key values and values
-being arrays of current model objects having the foreign/primary key
-value associated with the key.  This is hard to visualize, so I'll
-give an example.  Let's say you have the following associations
+The id_map is a performance enhancement that is used by the default
+association loaders and is also available to you.  It is a hash with keys
+foreign/primary key values, and values being arrays of current model
+objects having the foreign/primary key value associated with the key. 
+This may be hard to visualize, so I'll give an example.  Let's say you
+have the following associations
 
   Album.many_to_one :artist
   Album.one_to_many :tracks
@@ -113,53 +108,30 @@ and the following two albums in the database:
 
   album1 = Album.create(:artist_id=>3) # id: 1
   album2 = Album.create(:artist_id=>3) # id: 2
+  album3 = Album.create(:artist_id=>2) # id: 3
 
 If you try to eager load this dataset:
 
   Album.eager(:artist, :tracks).all
 
-Then the key_hash provided to the :eager_loader proc would be:
-
-  {:id=>{1=>[album1], 2=>[album2]}, :artist_id=>{3=>[album1, album2]}}
-
-Let's break down the reason for the makeup of this key_hash.  The hash has keys for
-each of foreign/primary keys used in the association.  In this case, the artist
-association needs the artist_id foreign key (since it is a many_to_one), and the
-tracks association needs the id primary key (since it is a one_to_many).
-
-If you only eagerly loaded the artist association:
-
-  Album.eager(:artist).all
-
-Then the key_hash would only contain artist_id information:
-
-  {:artist_id=>{3=>[album1, album2]}}
- 
-Likewise, if you only eagerly loaded the tracks association:
-
-  Album.eager(:tracks).all
-
-Then the key_hash would only contain id information:
-
-  {:id=>{1=>[album1], 2=>[album2]}}
-
-Now, the eager loader for the artist association is only going to care about the
-value of the artist_id key in the hash, so it's going to do the equivalent of:
+Then the id_map provided to the artist :eager_loader proc would be:
 
-  artist_id_map = key_hash[:artist_id] # {3=>[album1, album2]}
+  {3=>[album1, album2], 2=>[album3]}
 
-The artist_id_map contains a mapping of artist_id values to arrays of
-album objects.  Since it only has a single entry with a key of 3, when eagerly
-loading the artists, you only need to look for artists that have an id of 3.
+The artist id_map contains a mapping of artist_id values to arrays of
+album objects.  Since both album1 and album2 have the same artist_id,
+the are both in the array related to that key.  album3 has a different
+artist_id, so it is in a different array. Eager loading of artists is
+done by looking for any artist having one of the keys in the hash:
 
-  artists = Artist.where(:id=>artist_id_map.keys).all
+  artists = Artist.where(:id=>id_map.keys).all
 
 When the artists are retrieved, you can iterate over them, find entries
 with matching keys, and manually associate them to the albums:
 
   artists.each do |artist|
     # Find related albums using the artist_id_map
-    if albums = artist_id_map[artist.id]
+    if albums = id_map[artist.id]
       # Iterate over the albums
       albums.each do |album|
         # Manually set the artist association for each album
@@ -168,15 +140,14 @@ with matching keys, and manually associate them to the albums:
     end
   end
 
-Similarly, the eager loader for the tracks association is only going to care about the
-value of the id key in the hash:
+The id_map provided to the tracks :eager_loader proc would be:
 
-  id_map = key_hash[:id] # {1=>[album1], 2=>[album2]}
+  {1=>[album1], 2=>[album2], 3=>[album3]}
 
 Now the id_map contains a mapping of id values to arrays of album objects (in this
 case each array only has a single object, because id is the primary key).  So when
 looking for tracks to eagerly load, you only need to look for ones that have an
-album_id of 1 or 2:
+album_id with one of the keys in the hash:
 
   tracks = Track.where(:album_id=>id_map.keys).all
 
@@ -213,9 +184,9 @@ So putting everything together, the artist eager loader looks like:
 
   :eager_loader=>(proc do |eo_opts|
     eo_opts[:rows].each{|album| album.associations[:artist] = nil}
-    artist_id_map = eo_opts[:key_hash][:artist_id]
-    Artist.where(:id=>artist_id_map.keys).all do |artist|
-      if albums = artist_id_map[artist.id]
+    id_map = eo_opts[:id_map]
+    Artist.where(:id=>id_map.keys).all do |artist|
+      if albums = id_map[artist.id]
         albums.each do |album|
           album.associations[:artist] = artist
         end
@@ -227,7 +198,7 @@ and the tracks eager loader looks like:
 
   :eager_loader=>(proc do |eo_opts|
     eo_opts[:rows].each{|album| album.associations[:tracks] = []}
-    id_map = eo_opts[:key_hash][:id]
+    id_map = eo_opts[:id_map]
     Track.where(:id=>id_map.keys).all do |tracks|
       if albums = id_map[track.album_id]
         albums.each do |album|
@@ -245,14 +216,12 @@ the custom eager loaders described later in this page are more complex.
 Basically, the eager loading steps can be broken down into:
 
 1. Set default association values (nil/[]) for each of the current objects
-2. Build a custom key map mapping foreign/primary key values to arrays of
-   current objects (using the key_hash)
-3. Return just related associated objects by filtering the associated class
-   to include only matching values
-4. Iterating over the returned associated objects, indexing into the custom key
-   map using the foreign/primary key value in the associated object to get
+2. Return just related associated objects by filtering the associated class
+   to include only rows with keys present in the id_map.
+3. Iterating over the returned associated objects, indexing into the id_map
+   using the foreign/primary key value in the associated object to get
    current values associated to that specific object.
-5. For each of those current values, updating the cached association value to
+4. For each of those current values, updating the cached association value to
    include that specific object.
 
 Using the :eager_loader proc, you should be able to eagerly load all associations
@@ -631,7 +600,7 @@ name, with no duplicates?
     one_to_many :songs, :order=>:songs__name, \
       :dataset=>proc{Song.select(:songs.*).join(Lyric, :id=>:lyric_id, id=>[:composer_id, :arranger_id, :vocalist_id, :lyricist_id])}, \
       :eager_loader=>(proc do |eo|
-        h = eo[:key_hash][:id]
+        h = eo[:id_map]
         ids = h.keys
         eo[:rows].each{|r| r.associations[:songs] = []}
         Song.select(:songs.*, :lyrics__composer_id, :lyrics__arranger_id, :lyrics__vocalist_id, :lyrics__lyricist_id)\
@@ -662,11 +631,11 @@ associated tickets.
      :dataset=>proc{Ticket.filter(:project_id=>id).select{sum(hours).as(hours)}},
      :eager_loader=>(proc do |eo|
       eo[:rows].each{|p| p.associations[:ticket_hours] = nil}
-      Ticket.filter(:project_id=>eo[:key_hash][:id].keys).
+      Ticket.filter(:project_id=>eo[:id_map].keys).
        group(:project_id).
        select{[project_id, sum(hours).as(hours)]}.
        all do |t|
-        p = eo[:key_hash][:id][t.values.delete(:project_id)].first
+        p = eo[:id_map][t.values.delete(:project_id)].first
         p.associations[:ticket_hours] = t
        end
      end)

data/doc/association_basics.rdoc

@@ -473,7 +473,7 @@ associations (ones without conditions).
 == Name Collisions
 
 Because associations create instance methods, it's possible to override
-existing instance methods if you name an extension the same as an
+existing instance methods if you name an association the same as an
 existing method.  For example, <tt>values</tt> and <tt>associations</tt>
 would be bad association names.
 
@@ -1050,7 +1050,7 @@ Column in associated table that :right_key points to, as a symbol.
 Defaults to primary key of the associated table.
 
   Tag.set_primary_key :tid
-  Album.many_to_many :tags # :left_primary_key=>:tid
+  Album.many_to_many :tags # :right_primary_key=>:tid
 
 Can use an array of symbols for a composite key association.
 
@@ -1135,8 +1135,6 @@ Called after removing an object from the association:
 
 Called before the _<i>association</i>= method is called to modify the objects:
 
-Called before removing an object from the association:
-
   class Album
     # Don't associate the album with an artist if the year the album was
     # released is less than the year the artist/band started.
@@ -1223,13 +1221,9 @@ For many details and examples of custom eager loaders, please see the
 ==== :eager_loader_key
 
 A symbol for the key column to use to populate the key hash for the eager
-loader.  It can be necessary to specify this for custom eager loaders
-where the default key that would be used does not exist, as in that case, Sequel
-would think that the key values are all NULL, and would not attempt to
-eagerly load any associated objects for that association.  If you have a
-custom eager loader and aren't sure of a good value to use here, and you
-aren't using the key_hash (first argument to the eager_loader proc), then
-you can probably use the primary key column of the model.
+loader.  Generally does not need to be set manually, defaults to the key
+method used.  Can be set to nil to not populate the key hash (better for
+performance if a custom eager loader does not use the key_hash).
 
 ==== :eager_block
 
@@ -1340,6 +1334,11 @@ This is mostly useful if you have associations with the same name in many models
 to be able to easily tell which table alias corresponds to which association when eagerly
 graphing multiple associations with the same name.
 
+You can override this option on a per-graph basis by specifying the association as an
+SQL::AliasedExpression instead of a symbol:
+
+  Album.eager_graph(Sequel.as(:artist, :a))
+
 ==== :eager_grapher
 
 Sets up a custom grapher to use when eager loading the objects via eager_graph.
@@ -1465,13 +1464,9 @@ aliases defined with <tt>Model.def_column_alias</tt>:
     def_column_alias(:obj_id, :object_id)
   end
   class Obj < Sequel::Model
-    many_to_one :things, :key=>:object_id, :key_method=>:obj_id
+    one_to_many :things, :key=>:object_id, :key_method=>:obj_id
   end
 
-Note that for eager loading purposes, you generally need to set the
-<tt>:eager_loader_key</tt> option as well, specifying the underlying
-column(s) to use.
-
 ==== :key_column [+many_to_one+]
 
 Like the :key option, but :key references the method name, while

data/doc/release_notes/3.37.0.txt

@@ -0,0 +1,338 @@
+= New Features
+
+* Database#extension and Dataset#extension have been added and
+  make it much easier to use extensions that just define modules,
+  where you previously had to manually extend a Database or
+  Dataset object with the module to get the extension's behavior.
+  These methods operate similarly to model plugins, where you just
+  specify the extension symbol, except that you can specify multiple
+  extensions at once:
+
+    DB.extension(:pg_array, :pg_hstore)
+
+  For databases, these modify the Database itself (and
+  potentially all of its datasets).  Dataset#extension operates
+  like other dataset methods, returning a modified clone of
+  the dataset with the extension added:
+
+    dataset = dataset.extension(:columns_introspection)
+
+  Dataset#extension! has also been added for modifying the
+  receiver instead of returning a clone.
+
+  Not all extensions are usable by Database#extension or
+  Dataset#extension, the extension has to have specific support
+  for it.  The following extensions support both
+  Database#extension and Dataset#extension:
+
+  * columns_introspection
+  * query_literals
+  * split_array_nil
+
+  The following extensions support just Database#extension:
+
+  * arbitrary_servers
+  * looser_typecasting
+  * pg_array
+  * pg_auto_parameterize
+  * pg_hstore
+  * pg_inet
+  * pg_interval
+  * pg_json
+  * pg_range
+  * pg_statement_cache
+  * server_block
+
+  Any user that was loading these extensions with Sequel.extension
+  and then manually extending objects with the extension's module
+  is encouraged to switch to Database#extension and/or
+  Dataset#extension.
+
+* Dataset join methods now respect a :qualify=>:deep option
+  to do deep qualification of expressions, allowing qualification
+  of subexpressions in the expression tree.  This can allow you
+  to do things like:
+
+     DB[:a].join(:b, {:c.cast(Integer)=>:d.cast(Integer)},
+                 :qualify=>:deep)
+     # SELECT * FROM a INNER JOIN b
+     # ON (CAST(b.c AS INTEGER) = CAST(a.d AS INTEGER))
+
+  For backwards compatibility, by default Sequel will only do
+  automatic qualification if the arguments are simple symbols.
+  This may change in a future version, if automatic qualification
+  of only symbols is desired, switch to using :qualify=>:symbol.
+  
+  You can also choose to do no automatic qualification using the
+  :qualify=>false option.
+
+* All of Sequel's model associations now work with key expressions
+  that are not simple column references, without creating a fully
+  custom association.  So you can create associations where the
+  primary/foreign key values are stored in PostgreSQL array or
+  hstore columns, for example.
+
+* The pg_array extension has now been made more generic, so that it
+  is easy to support array types for any scalar type that is
+  currently supported.  All scalar types that Sequel's postgres
+  adapter supports now have corresponding array types supported in
+  the pg_array extension.  So if you load the pg_array extension and
+  return a date array column, the returned values will be arrays of
+  ruby Date objects.
+
+  Other pg_* extensions that add support for PostgreSQL-specific
+  scalar types now support array versions of those types if the
+  pg_array extension is loaded first.
+
+* A pg_range extension has been added, making it easy to deal
+  with PostgreSQL 9.2+'s range types.  As ruby's Range class does
+  not support all PostgreSQL range type values (such as empty ranges,
+  unbounded ranges, or ranges with an exlusive beginning), range
+  types are returned as instances of Sequel::Postgres::PGRange, which
+  has an API similar to Range.  You can turn a PGRange into a Range
+  using PGRange#to_range, assuming that the range type value does not
+  use features that are incompatible with ruby's Range class.
+
+  The pg_range extension supports all range types supported by
+  default in PostgreSQL 9.2, and makes it easy to support custom
+  range types.
+
+* A pg_range_ops extension has been added, which adds DSL support for
+  PostgreSQL range operators and functions, similar to the
+  pg_array_ops and pg_hstore_ops extensions.
+
+* A pg_interval extension has been added, which makes Sequel return
+  PostgreSQL interval types as instances of ActiveSupport::Duration.
+  This is useful if you want to take the interval value and use it in
+  calculations in ruby (assuming you load the appropriate parts of
+  ActiveSupport).
+
+* A split_array_nil extension has been added, which changes how Sequel
+  compiles IN/NOT IN expressions with arrays with nil values.
+
+    where(:col=>[1, nil])
+    # Default:
+    #   WHERE (col IN (1, NULL))
+    # with split_array_nil extension:
+    #   WHERE ((col IN (1)) OR (col IS NULL))
+
+    exclude(:col=>[1, nil])
+    # Default:
+    #   WHERE (col NOT IN (1, NULL))
+    # with split_array_nil extension:
+    #   WHERE ((col NOT IN (1)) AND (col IS NOT NULL))
+
+* The nested_attributes plugin now allows the :fields option to
+  be a proc, which is called with the associated object and should
+  return an array of allowable fields.
+
+* You can now specify the graph alias base when using eager_graph on
+  a per-call basis.  Previously, it could only be set on a per
+  association basis.  This is helpful if you have multiple
+  associations to the same class, and are cascading the eager graph to
+  dependent associations of that class for both of the associations.
+  Previously, there was no way to manually give descriptive names to
+  the tables in the cascaded associations, but you can now do so
+  by passing the association as an Sequel::SQL::AliasedExpression
+  instance instead of a plain Symbol.  Here's a usage example:
+
+    ds = Game.eager_graph(:winner=>:players.as(:winning_players),
+                          :loser=>:players.as(:losing_players)).
+          where(:winning_players__name=>'A',
+                :losing_players__name=>'B')
+
+* many_through_many associations now differentiate between column
+  references and method references, by supporting the
+  :left_primary_key_column and :right_primary_key_method options that
+  many_to_many associations support.
+
+* Custom :eager_loader procs that accept a single hash argument now
+  have an additional entry passed in the hash, :id_map, which is
+  easier to use than the :key_hash entry (which is still present for
+  backwards compatibility).  Anyone with custom :eager_loader procs is
+  encouraged to switch from using :key_hash to :id_map.
+
+* You can now override the create_table/alter_table schema generators
+  per database/adapter.  This allows for database specific generator
+  subclasses, which have methods for unique features for that
+  database.
+
+* You can now setup exclusion constraints on PostgreSQL using the
+  create_table and alter_table schema generators:
+
+    DB.create_table(:t) do
+      ...
+      exclusion_constraint([[:col1, '&&'], [:col2, '=']])
+      # EXCLUDE USING gist (col1 WITH &&, col2 WITH =)
+    end
+
+  One common use for exclusion constraints is to make sure that no two
+  rows have overlapping values/ranges/circles.
+
+* When adding foreign key constraints to an existing table on
+  PostgreSQL, you can use the :not_valid option to mark the constraint
+  as not yet valid.  This will make it so that future changes to the
+  table need to respect the foreign key constraint, but existing rows
+  do not.  After cleaning up the existing data, you can then use the
+  alter_table validate_constraint method to mark the constraint as
+  valid.
+
+* An eval_inspect extension has been added that attempts to do
+  do the following for Sequel::SQL::Expression instances:
+
+    eval(obj.inspect) == obj # => true
+
+  There are a lot of cases that this extension does not handle, but
+  it does a decent job in most cases.  This is currently only used
+  internally in a specific case in the schema_dumper extension.
+
+= Other Improvements
+
+* The filter by associations support now respects the method
+  reference vs column reference distinction that other parts of the
+  association code have respected since 3.32.0.
+
+* In the nested_attributes plugin, new one_to_one associated
+  values are saved once instead of twice.  Previously it attempted to
+  save them before they were associated to the current model object,
+  which can violate some validations/constraints.
+
+* When saving an associated object in the one_to_one association
+  setter method, Sequel no longer adds an unnecessary filter
+  condition when nullifying the foreign key for existing rows
+  in the associated table.
+
+* The list plugin's before_create method now calls super, which
+  fixes usage when other plugins that define before_create are loaded
+  before it.
+
+* In the pg_array extension, when typecasting an Array to PGArray,
+  a recursive map is done on the input array to convert each value
+  in the input array to the expected type, using the typecasting
+  method that would be used for the scalar value.  For example, for
+  model objects, where ids is an integer array column:
+
+   model.set(:ids=>['1', '2']).ids.to_a # => [1, 2]
+
+* The pg_array extension now correctly handles bytea arrays used
+  in bound variables.
+
+* The pg_array extension no longer uses the JSON-based parser for
+  floating point types, since it doesn't handle NaN and Infinity
+  values correctly.
+
+* When typecasting in the pg_array extension, PGArray values are
+  only returned verbatim if they have a matching database type.
+  Otherwise, the underlying array is rewrapped in a new PGArray
+  value with the correct database type.
+
+* H2 clob types are now recognized as strings instead of blobs.
+  Previously the code attempted to do this, but it didn't do so
+  correctly.
+
+* The jdbc/postgres adapter now converts scalar values of
+  the array to the appropriate type.  Previously, if you retrieved
+  a date array, you got back a ruby array of JavaSQL::SQL::Date
+  instances.  Now, you get back a ruby array of ruby Date instances.
+
+* The schema_dumper extension now dumps migrations as change
+  migrations, instead of separate up/down migrations, resulting in
+  simpler code.
+
+* When dumping non-integer foreign keys in the schema dumper, an
+  explicit type is now used.  Previously, the column would have been
+  dumped as an integer column.
+
+* When dumping unsigned integer columns in the schema dumper, add a
+  column > 0 constraint in the dumped migration.
+
+* On Microsoft SQL Server, when updating a dataset with a limit,
+  the limit is now respected.
+
+* When emulating offset using the ROW_NUMBER window function,
+  do not require that the dataset be ordered.  If an order is
+  not provided, default to ordering on all of the columns in
+  the dataset.  If you want to override the default order used
+  in such a case, you need to override the default_offset_order
+  method for the dataset.
+
+* On SQLite, casting to Date/Time/DateTime now calls an SQLite
+  date/datetime function instead of using a cast, as SQLite treats
+  such a cast as a cast to integer.
+
+* When using JRuby 1.6 in ruby 1.9 mode and typecasting a time
+  column, workaround a bug where Time#nsec is 0 even though
+  Time#usec is not.
+
+* The odbc/mssql adapter now correctly handles the case where
+  SCOPE_IDENTITY returns NULL after an insert.
+
+* bin/sequel now accepts multiple -l options for logging to multiple
+  output files.
+
+* In addition to Sequel's rigorous pre-push testing, Sequel now
+  also uses TravisCI for continuous integration testing across
+  a wider range of ruby implementations.
+
+= Backwards Compatibility
+
+* The keys in the :key_hash entry passed to the :eager_loader proc
+  are now method references instead of column references.  For most
+  associations, they are the same thing, but for associations using
+  the :key_column/:primary_key_column/:left_primary_key_column
+  options, the values could be different.  If you were using one
+  of those options and had a custom eager_loader, you should switch
+  from indexing into the :key_hash option to just using the :id_map
+  option.
+
+* The :key_hash entry passed to the :eager_loader proc is now no
+  longer guaranteed to contain key maps for associations other than
+  the one currently being eagerly loaded.  Previously, it contained 
+  key maps for all associations that were being eagerly loaded.  If
+  you have a custom :eager_loader proc that accessed a key map for
+  a separate association that was being loaded concurrently, you'll
+  now have to build the key map manually if it doesn't exist.
+
+* If you previously explicitly specified an :eager_loader_key option
+  when defining an association, you may need to change it so that it
+  is a method reference instead of a column reference, or possibly
+  just omit the option.
+
+* If you have a custom :eager_loader proc for an association where
+  the default :eager_loader_key option references a method that
+  the model does not respond to (or raises an exception), you may
+  need to specify the :eager_loader_key=>nil option.
+
+* In the pg_auto_parameterize extension, String values are no longer
+  automatically casted to text.  This is because the default type of
+  a string literal in PostgreSQL is unknown, not text.  This makes it
+  much less likely to require manual casts, but has the potential to
+  break existing code relying on the automatic cast to text.  As a
+  work around, any query that can no longer be automatically
+  parameterized after this query just needs to add manual casting
+  to text.
+
+* Sequel now raises an exception if you attempt to clone associations
+  with different types, except if one type is one_to_many and the
+  other is one_to_one.  Cloning from other types was usually a bug,
+  and raising an exception early will make it much easier to track
+  such bugs down.
+
+* When running the plugin/extension and PostgreSQL adapter specs,
+  a json library is now required.
+
+* The json/postgres adapter array typecasting internals have been
+  modified, if you were relying on the internals, you may need to
+  update your code.
+
+* The pg_array extension internals changed significantly.  PGArray
+  no longer has any subclasses by default, as parsing is now done
+  in separate objects.  Anyone relying on the pg_array internals
+  will need to update their code.
+
+* The postgres adapter no longer sets up type conversion of int2vector
+  and money types, since in both cases the conversion was incorrect in
+  most cases.  These types will now be returned as strings.  If you are
+  relying on the conversion, you'll need to add your own custom type
+  procs.
+