sequel 3.28.0 → 3.29.0

data/CHANGELOG

@@ -1,3 +1,119 @@
+=== 3.29.0 (2011-11-01)
+
+* Allow Model.dataset_module to take a Module instance (jeremyevans)
+
+* Apply Model.[] optimization in more cases (jeremyevans)
+
+* Fix Model.[] optimization when dataset uses identifier_input_method different than database (jeremyevans)
+
+* Work around pragma bug on jdbc/sqlite when emulating alter table support (jeremyevans)
+
+* Database#<< and Dataset#<< now return self so they can be safely chained (jeremyevans)
+
+* Fully support using an aliased table name as the :join_table option for a many_to_many association (jeremyevans)
+
+* Make like case sensitive on SQLite and Microsoft SQL Server (use ilike for case insensitive matching) (jeremyevans)
+
+* Add Database#extend_datasets for the equivalent of extending of the Database object's datasets with a module (jeremyevans)
+
+* Speed up Dataset #map, #to_hash, and related methods if an array of symbols is given (jeremyevans)
+
+* Add Database#dataset_class for modifying the class used for datasets for a single Database object (jeremyevans)
+
+* Plugins that override Model.load should be modified to override Model.call instead (jeremyevans)
+
+* Speed up loading model objects from the database by up to 7-16% (jeremyevans)
+
+* Create accessor methods for all columns in a model's table, even if the dataset doesn't select the columns (jeremyevans)
+
+* Add mock adapter for better mocking of a database connection (jeremyevans)
+
+* Have models pass their dataset instead of table name to Database#schema (jeremyevans)
+
+* Allow Database#schema to take a dataset as the table argument, and use its identifier input/output methods (jeremyevans)
+
+* Significant improvements to the db2 adapter (jeremyevans)
+
+* Handle methods with names that can't be called directly in Model.def_dataset_method (jeremyevans)
+
+* Add dataset_associations plugin for making dataset methods that return datasets of associated objects (jeremyevans)
+
+* Don't allow Model.def_dataset_method to override private model methods (jeremyevans)
+
+* Parsing primary key information from system tables in the shared MSSQL adapter (jeremyevans)
+
+* Fix handling of composite primary keys when emulating alter table operations on SQLite (jeremyevans)
+
+* Emulate add_constraint and drop_constraint alter table operations on SQLite (jeremyevans)
+
+* Apply the correct pragmas when connecting to SQLite via the Amalgalite and Swift adapters (jeremyevans)
+
+* Fix bound variable usage for some types (e.g. Date) when used outside of prepared statements on SQLite (jeremyevans)
+
+* Work around SQLite column naming bug when using subselects (jeremyevans)
+
+* Make prepared_statements plugin work with adapters that require type specifiers for variable placeholders, such as oracle (jeremyevans)
+
+* Add savepoint support to the generic JDBC transaction support (used by 6 jdbc subadapters) (jeremyevans)
+
+* Add native prepared statement support to the oracle adapter (jeremyevans)
+
+* Support sharding correctly by default when using transactions in model saving/destroying (jeremyevans)
+
+* Add Database#in_transaction? method for checking if you are already in a transaction (jeremyevans)
+
+* Add after_commit, after_rollback, after_destroy_commit, and after_destroy_rollback hooks to Model objects (jeremyevans)
+
+* Add after_commit and after_rollback hooks to Database objects (jeremyevans)
+
+* Support savepoints inside prepared transactions on MySQL (jeremyevans)
+
+* Support opening transactions to multiple shards of the same Database object in the same Thread (jeremyevans)
+
+* Add Sequel.transaction for running transactions on multiple databases at the same time (jeremyevans)
+
+* Support :rollback => :always option in Database#transaction to always rollback the transaction (jeremyevans)
+
+* Support :rollback => :reraise option in Database#transaction to reraise the Sequel::Rollback exception (jeremyevans)
+
+* Add support for connecting to Apache Derby databases using the jdbc adapter (jeremyevans)
+
+* Add support for connecting to HSQLDB databases using the jdbc adapter (jeremyevans)
+
+* Fix inserting all default values into a table on DB2 (jeremyevans)
+
+* Add :qualify option to many_to_one associations for whether to qualify the primary key column with the associated table (jeremyevans)
+
+* Modify rcte_tree plugin to use column aliases if recursive CTEs require them (jeremyevans)
+
+* Add Dataset#recursive_cte_requires_column_aliases? method to check if you must provide an argument list for a recursive CTE (jeremyevans)
+
+* Much better support for Oracle in both the oci8-based oracle adapter and the jdbc oracle subadapter (jeremyevans)
+
+* Handle CTEs in subselects in more places on databases that don't natively support CTEs in subselects (jeremyevans)
+
+* Change Dataset#to_hash to not call the row_proc if 2 arguments are given (jeremyevans)
+
+* Change Dataset#map to not call the row_proc if an argument is given (jeremyevans)
+
+* Make Dataset#select_map and #select_order_map return an array of single element arrays if given an array with a single symbol (jeremyevans)
+
+* Make Dataset#columns work correctly on jdbc, odbc, ado, and dbi adapters when using an emulated offset on MSSQL and DB2 (jeremyevans)
+
+* Add Database#listen and #notify to the postgres adapter, for LISTEN and NOTIFY support (jeremyevans)
+
+* Emulate the bitwise compliment operator on h2 (jeremyevans)
+
+* Fix improper handling of emulated bitwise operators with more than two arguments (jeremyevans)
+
+* Allow convert_invalid_date_time to be set on a per-Database basis in the mysql adapter (jeremyevans)
+
+* Allow convert_tinyint_to_bool to be set on a per-Database basis in the mysql and mysql2 adapters (jeremyevans)
+
+* Allow per-Database override of the typeconversion procs on the mysql, sqlite, and ibmdb adapters (jeremyevans)
+
+* Add Database#timezone accessor, for overriding Sequel.database_timezone per Database object (jeremyevans)
+
 === 3.28.0 (2011-10-03)
 
 * Add firebird jdbc subadapter (jeremyevans)
@@ -3248,9 +3364,9 @@
 
 === 0.1.9.3 (2007-08-10)
 
-* Added support for specifying field size in schema definitions (thanks Florian Aßmann.)
+* Added support for specifying field size in schema definitions (thanks Florian Assmann.)
 
-* Added migration code based on work by Florian Aßmann.
+* Added migration code based on work by Florian Assmann.
 
 * Reintroduced metaid dependency. No need to keep a local copy of it.
 
@@ -3328,7 +3444,7 @@
 
 * Fixed Dataset#first to include a LIMIT clause for a single record.
 
-* Small fix to Postgres driver to return a primary_key value for the inserted record if it is specified in the insertion values (thanks Florian Aßmann and Pedro Gutierrez).
+* Small fix to Postgres driver to return a primary_key value for the inserted record if it is specified in the insertion values (thanks Florian Assmann and Pedro Gutierrez).
 
 * Fixed Symbol#DESC to support qualified notation (thanks Pedro Gutierrez).
 

data/Rakefile

@@ -55,7 +55,7 @@ end
 
 desc "Make local version of website"
 task :website do
-  sh %{#{RUBY} www/make_www.rb}
+  sh %{#{FileUtils::RUBY} www/make_www.rb}
 end
 
 desc "Make rdoc for website"
@@ -97,11 +97,13 @@ begin
     require "spec/rake/spectask"
     spec_class = Spec::Rake::SpecTask
     spec_files_meth = :spec_files=
+    spec_opts_meth = :spec_opts=
   rescue LoadError
     # RSpec 2
     require "rspec/core/rake_task"
     spec_class = RSpec::Core::RakeTask
     spec_files_meth = :pattern=
+    spec_opts_meth = :rspec_opts=
   end
 
   spec = lambda do |name, files, d|
@@ -110,7 +112,7 @@ begin
     desc d
     spec_class.new(name) do |t|
       t.send spec_files_meth, files
-      t.spec_opts = ENV['SEQUEL_SPEC_OPTS'].split if ENV['SEQUEL_SPEC_OPTS']
+      t.send spec_opts_meth, ENV['SEQUEL_SPEC_OPTS'].split if ENV['SEQUEL_SPEC_OPTS']
     end
   end
 
@@ -159,5 +161,5 @@ end
 
 desc "Check syntax of all .rb files"
 task :check_syntax do
-  Dir['**/*.rb'].each{|file| print `#{RUBY} -c #{file} | fgrep -v "Syntax OK"`}
+  Dir['**/*.rb'].each{|file| print `#{FileUtils::RUBY} -c #{file} | fgrep -v "Syntax OK"`}
 end

data/bin/sequel

@@ -112,11 +112,7 @@ end
 
 connect_proc = lambda do |database|
   db = if database.nil? || database.empty?
-    db = Sequel::Database.new(:quote_identifiers=>false)
-    def db.connect(*args); Object.new; end
-    db.identifier_input_method = nil
-    db.identifier_output_method = nil
-    db
+    Sequel.connect('mock:///', db_opts)
   elsif File.exist?(database)
     require 'yaml'
     env ||= "development"

data/doc/model_hooks.rdoc

@@ -67,7 +67,15 @@ Sequel calls hooks in the following order when destroying an existing object:
 
 Note that these hooks are only called when using <tt>Model#destroy</tt>, they are not called if you use <tt>Model#delete</tt>.
 
-<tt>Sequel::Model</tt> does support one additional hook, +after_intialize+, which is called after the model object has been initalized.  It can be used to set default attribute values for new objects, since by default new <tt>Sequel::Model</tt> objects have no attributes, and the attributes are not filled in until the model object is saved.  You should be careful when you are using +after_initialize+, since it is called for every created record.  So if you run a query that returns 1000 model objects, it will be called 1000 times.  If you only want to change the behavior for new records, you can override the +initialize_set+ private method, which is called with the hash passed to +initialize+. 
+<tt>Sequel::Model</tt> does support a few additional hooks. One is +after_intialize+, which is called after the model object has been initalized.  It can be used to set default attribute values for new objects, since by default new <tt>Sequel::Model</tt> objects have no attributes, and the attributes are not filled in until the model object is saved.  You should be careful when you are using +after_initialize+, since it is called for every created record.  So if you run a query that returns 1000 model objects, it will be called 1000 times.  If you only want to change the behavior for new records, you can override the +initialize_set+ private method, which is called with the hash passed to +initialize+.
+
+== Transaction-related Hooks
+
+There are four other model hooks that <tt>Sequel::Model</tt> supports, all related to transactions.  These are +after_commit+, +after_rollback+, +after_destroy_commit+, and +after_destroy_rollback+.  +after_commit+ is called after the transaction in which you saved the object commits, only if it commits.  +after_rollback+ is called after the transaction in which you saved the object rolls back, if it rolls back.  +after_destroy_commit+ is called after the transaction in which you destroyed the object commits, if it commits.  +after_destroy_rollback+ is called after the transaction in which you destroyed the object rolls back, if it rolls back.
+
+If you aren't using transactions when saving or destroying model objects, and there isn't a currently open transaction, +after_commit+ and +after_destroy_commit+ will be called after +after_save+ and +after_destroy+, respectively, and +after_rollback+ and +after_destroy_rollback+ won't be called at all.
+
+The purpose of these hooks is dealing with external systems that are interacting with the same database.  For example, let's say you have a model that stores a picture, and you have a background job library that makes thumbnails of all of the pictures.  So when a model object is created, you want to add a background job that will create the thumbnail for the picture.  If you used after_save for this and transactions are being used, you are subject to a race condition where the background job library will check the database table for the record before the transaction that saved the record commits, and it won't be able to see the record's data.  Using after_commit, you are guaranteed that the background job library will not get notified of the record until after the transaction commits and the data is viewable.
 
 == Running Hooks
 

data/doc/opening_databases.rdoc

@@ -66,24 +66,24 @@ For example:
 
 These options are shared by all adapters unless otherwise noted.
 
-* :adapter - The adapter to use
-* :database - The name of the database to which to connect
-* :default_schema - The database schema to use by default.
-* :host - The hostname of the database server to which to connect
-* :logger - An array of SQL loggers to log to
-* :loggers - An array of SQL loggers to log to
-* :password - The password for the user account
-* :servers - A hash with symbol keys and hash or proc values, used with master/slave/partitioned database configurations
-* :single_threaded - Whether to use a single-threaded (non-thread safe) connection pool
-* :test - Whether to test that a valid database connection can be made (false by default)
-* :user - The user account name to use logging in
+:adapter :: The adapter to use
+:database :: The name of the database to which to connect
+:default_schema :: The database schema to use by default.
+:host :: The hostname of the database server to which to connect
+:logger :: An array of SQL loggers to log to
+:loggers :: An array of SQL loggers to log to
+:password :: The password for the user account
+:servers :: A hash with symbol keys and hash or proc values, used with master/slave/partitioned database configurations
+:single_threaded :: Whether to use a single-threaded (non-thread safe) connection pool
+:test :: Whether to test that a valid database connection can be made (false by default)
+:user :: The user account name to use logging in
 
 The following options can be specified and are passed to the the database's internal connection pool.
 
-* :after_connect - A proc called after a new connection is made, with the connection object (default: nil)
-* :max_connections - The maximum size of the connection pool (default: 4 connections on most databases)
-* :pool_sleep_time - The number of seconds to sleep before trying to acquire a connection again (default: 0.001 seconds)
-* :pool_timeout - The number of seconds to wait if a connection cannot be acquired before raising an error (default: 5 seconds)
+:after_connect :: A proc called after a new connection is made, with the connection object (default: nil)
+:max_connections :: The maximum size of the connection pool (default: 4 connections on most databases)
+:pool_sleep_time :: The number of seconds to sleep before trying to acquire a connection again (default: 0.001 seconds)
+:pool_timeout :: The number of seconds to wait if a connection cannot be acquired before raising an error (default: 5 seconds)
 
 == Adapter specific connection options
 
@@ -138,8 +138,8 @@ Amalgalite is an ruby extension that provides self contained access to SQLite,
 so you don't need to install SQLite separately.  As amalgalite is a file backed
 database, the :host, :user, and :password options are not used.
 
-* :database - The name of the database file
-* :timeout - The busy timeout period given in milliseconds
+:database :: The name of the database file
+:timeout :: The busy timeout period given in milliseconds
 
 Without a database argument, assumes a memory database, so you can do:
 
@@ -159,8 +159,8 @@ instead for new DB2 work, as it is better supported.
 
 Allows access to a multitude of databases via ruby-dbi.  Additional options:
 
-* :db_type - Specifying 'mssql' allows Microsoft SQL Server specific syntax to
-  be used.  Otherwise has no effect.
+:db_type :: Specifying 'mssql' allows Microsoft SQL Server specific syntax to
+            be used.  Otherwise has no effect.
 
 DBI connection strings are a preprocessed a bit, and are specified with a dbi-
 in front of the protocol.  Examples:
@@ -258,19 +258,24 @@ Example connection strings:
   jdbc:postgresql://localhost/database?user=username
   jdbc:mysql://localhost/test?user=root&password=root
   jdbc:h2:mem:
+  jdbc:hsqldb:mem:mymemdb
+  jdbc:derby:memory:myDb;create=true
   jdbc:sqlserver://localhost;database=sequel_test;integratedSecurity=true
   jdbc:jtds:sqlserver://localhost/sequel_test;user=sequel_test;password=sequel_test
-  
+  jdbc:oracle:thin:user/password@localhost:1521:database
+  jdbc:db2://localhost:3700/database:user=user;password=password;
+  jdbc:firebirdsql:localhost/3050:/path/to/database.fdb
+
 You can also use JNDI connection strings:
 
   jdbc:jndi:java:comp/env/jndi_resource_name
 
 The following additional options are supported:
 
-* :convert_types - If set to false, does not attempt to convert some Java types to ruby types.
-  Setting to false roughly doubles performance when selecting large numbers of rows.
-  Note that you can't provide this option inside the connection string (as that is passed
-  directly to JDBC), you have to pass it as a separate option.
+:convert_types :: If set to false, does not attempt to convert some Java types to ruby types.
+                  Setting to false roughly doubles performance when selecting large numbers of rows.
+                  Note that you can't provide this option inside the connection string (as that is passed
+                  directly to JDBC), you have to pass it as a separate option.
 
 === mysql 
 
@@ -281,16 +286,16 @@ ActiveRecord, it requires the native adapter.
 
 The following additional options are supported:
 
-* :auto_is_null - If set to true, makes "WHERE primary_key IS NULL" select the last inserted id.
-* :charset - Same as :encoding, :encoding takes precedence.
-* :compress - Whether to compress data sent/received via the socket connection.
-* :config_default_group - The default group to read from the in the MySQL config file.
-* :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE option on the connection with the given value.
-* :encoding - Specify the encoding/character set to use for the connection.
-* :socket - Can be used to specify a Unix socket file to connect to instead of a TCP host and port.
-* :timeout - Sets the wait_timeout for the connection, defaults to 1 month.
-* :read_timeout - Set the timeout in seconds for reading back results to a query.
-* :connect_timeout - Set the timeout in seconds before a connection attempt is abandoned.
+:auto_is_null :: If set to true, makes "WHERE primary_key IS NULL" select the last inserted id.
+:charset :: Same as :encoding, :encoding takes precedence.
+:compress :: Whether to compress data sent/received via the socket connection.
+:config_default_group :: The default group to read from the in the MySQL config file.
+:config_local_infile :: If provided, sets the Mysql::OPT_LOCAL_INFILE option on the connection with the given value.
+:encoding :: Specify the encoding/character set to use for the connection.
+:socket :: Can be used to specify a Unix socket file to connect to instead of a TCP host and port.
+:timeout :: Sets the wait_timeout for the connection, defaults to 1 month.
+:read_timeout :: Set the timeout in seconds for reading back results to a query.
+:connect_timeout :: Set the timeout in seconds before a connection attempt is abandoned.
 
 === mysql2
 
@@ -307,8 +312,8 @@ The :database option given ODBC database should be the DSN (Descriptive Service
 
 The :host and :port options are not respected. The following additional options are supported:
 
-* :db_type - Can be specified as 'mssql' or 'progress' to use SQL syntax specific to those databases.
-* :driver - The name of the ODBC driver to utilize.
+:db_type :: Can be specified as 'mssql' or 'progress' to use SQL syntax specific to those databases.
+:driver :: The name of the ODBC driver to utilize.
 
 === openbase 
 
@@ -320,7 +325,11 @@ Requires: oci8
 
 The following additional options are supported:
 
-* :privilege - The Oracle privilege level.
+:autosequence :: Set to true to use Sequel's conventions to guess the sequence to use for datasets.  False
+                 by default.
+:prefetch_rows :: The number of rows to prefetch.  Defaults to 1, a larger number can be specified
+                  and will improve performance when retrieving a large number of rows.
+:privilege :: The Oracle privilege level.
 
 === postgres
 
@@ -331,8 +340,8 @@ The pg library is the best supported, as it supports real bound variables and pr
 
 The following additional options are supported:
 
-* :charset - Same as :encoding, :encoding takes precedence
-* :encoding - Set the client_encoding to the given string
+:charset :: Same as :encoding, :encoding takes precedence
+:encoding :: Set the client_encoding to the given string
 
 === sqlite
 
@@ -359,7 +368,7 @@ Examples:
 
 The following additional options are supported:
 
-* :timeout - the busy timeout to use in milliseconds (default: 5000).
+:timeout :: the busy timeout to use in milliseconds (default: 5000).
 
 === swift
 

data/doc/prepared_statements.rdoc

@@ -9,6 +9,7 @@ the following adapters:
 * jdbc
 * mysql (prepared statements only)
 * mysql2 (prepared statements only)
+* oracle (requires type specifiers for nil/NULL values)
 * postgres (when using the pg driver, may require type specifiers)
 * sqlite
 * tinytds
@@ -80,20 +81,20 @@ and update queries, the hash to insert/update is passed to +prepare+:
 
 If you are using the ruby-postgres or postgres-pr driver, PostgreSQL uses the
 default emulated support.  If you are using ruby-pg, there is native support,
-but it may require type specifiers.  This is easy if you have
+but it may require type specifiers on some old versions (generally not anymore).
 direct control over the SQL string, but since Sequel abstracts that, the types
-can be specified another way.  This is done by adding a __* suffix to the
-placeholder symbol (e.g. :$name__text, which will be compiled to "$1::text"
-in the SQL).  Prepared statements are always server side.
+You can add a __* suffix to the placeholder symbol to specify a type, which
+casts to that type in the SQL (e.g.  :$name__text, which will be compiled to
+"$1::text" in the SQL).  Prepared statements are always server side.
 
 === SQLite
 
 SQLite supports both prepared statements and bound variables.  Prepared
 statements are cached per connection.
 
-=== MySQL
+=== MySQL/Mysql2
 
-The MySQL ruby driver does not support bound variables, so the bound
+The MySQL/Mysql2 ruby drivers do not support bound variables, so the bound
 variable methods fall back to string interpolation.  It uses server side
 prepared statements.
 
@@ -105,6 +106,26 @@ over JDBC, you can add the prepareThreshold=N parameter to the connection
 string, which will use a server side prepared statement after N calls to
 the prepared statement.
 
+=== TinyTDS
+
+Uses the sp_executesql stored procedure with bound variables, since
+Microsoft SQL Server doesn't support true prepared statements.
+
+=== IBM_DB
+
+DB2 supports both prepared statements and bound variables.  Prepared
+statement objects are cached per connection.
+
+=== Oracle
+
+Oracle supports both prepared statements and bound variables.  Prepared
+statements (OCI8::Cursor objects) are cached per connection.  If you
+ever plan to use a nil/NULL value as a bound variable/prepared statement
+value, you must specify the type in the placeholder using a __* suffix.
+You can use any of the schema types that Sequel supports, such as
+:$name__string or :$num__integer.  Using blobs as bound variables is
+not currently supported.
+
 === All Others
 
 Support is emulated using interpolation.

data/doc/release_notes/3.28.0.txt

@@ -64,11 +64,11 @@
   query types that only load the related records from the database.
   The available values for the :eager_limit_strategy option are:
 
-    :window_function: This uses the row_number window function
+    :window_function - This uses the row_number window function
       partitioned by the related key fields.  It can only be used
       on databases that support window functions (PostgreSQL 8.4+,
       Microsoft SQL Server 2005+, DB2).
-    :correlated_subquery: This uses a correlated subquery that is
+    :correlated_subquery - This uses a correlated subquery that is
       limited.  It works on most databases except MySQL and DB2.
 
   You can provide a value of true as the option to have Sequel

data/doc/release_notes/3.29.0.txt

@@ -0,0 +1,459 @@
+= New Adapter Support
+
+* Sequel now has much better support for Oracle, both in the
+  ruby-oci8-based oracle adapter and in the jdbc/oracle adapter.
+
+* Sequel now has much better support for connecting to HSQLDB
+  using the jdbc adapter.  This support does not work correctly
+  with the jdbc-hsqldb gem, since the version it uses is too
+  old.  You'll need to load the .jar file manually until the
+  gem is updated.
+
+* Sequel now has much better support for connecting to Apache
+  Derby databases using the jdbc adapter.  This works with
+  the jdbc-derby gem, but it's recommend you grab an updated
+  .jar file as the jdbc-derby gem doesn't currently support
+  truncate or booleans.
+
+* The db2 adapter has had most of the remaining issues fixed,
+  and can now run Sequel's test suite cleanly.  It's still
+  recommended that users switch to the ibmdb adapter if they
+  are connecting to DB2.
+
+* A mock adapter has been added which provides a mock Database
+  object that allows you to easily set the returned rows, the
+  number of rows modified by update/delete, and the
+  autogenerating primary key integer for insert.  It also allows
+  you to set specific columns in the dataset when retrieving
+  rows.  The specs were full of partial implementations of
+  mock adapters, this mock adapter is much more complete and
+  offers full support for mocking transactions and database
+  sharding.  Example:
+
+    DB = Sequel.mock(:fetch=>{:id=>1}, :numrows=>2, :autoid=>3)
+    DB[:items].all            # => [{:id => 1}]
+    DB[:items].insert         # => 3
+    DB[:items].insert         # => 4
+    DB[:items].delete         # => 2
+    DB[:items].update(:id=>2) # => 2
+    DB.sqls # => ['SELECT ...', 'INSERT ...', ...]
+
+  In addition to being useful in the specs, the mock adapter is
+  also used if you use bin/sequel without a database argument,
+  which makes it much easier to play around with Sequel on the
+  command line without being tied to a real database.
+
+= New Transaction Features
+
+* Database after_commit and after_rollback hooks have been added,
+  allowing you to set procs that are called after the currently-
+  in-effect transaction commits or rolls back.  If the Database
+  is not currently in a transaction, the after_commit proc is
+  called immediately and the after_rollback proc is ignored.
+
+* Model after_commit, after_rollback, after_destroy_commit, and
+  after_destroy_rollback hooks have been added that use the new
+  Database after_commit/after_rollback hook to execute code after
+  commit or rollback.
+
+* Database#transaction now supports a :rollback => :reraise option
+  to reraise any Sequel::Rollback exceptions raised by the block.
+
+* Database#transaction now supports a :rollback => :always option
+  to always rollback the transaction, which is mostly useful when
+  using transaction-based testing.
+
+* Sequel.transaction has been added, allowing you to run
+  simultaneous transactions on multiple Database objects:
+
+    Sequel.transaction([DB1, DB2]){...}
+    # similar to:
+    DB1.transaction{DB2.transaction{...}}
+
+  You can combine this with the :rollback => :always option to
+  easily use multiple databases in the same test suite and make sure
+  that changes are rolled back on all of them.
+
+* Database#in_transaction? has been added so that users can detect
+  whether the code is currently inside a transaction.
+
+* The generic JDBC transaction support, used by 6 of Sequel's jdbc
+  subapters, now supports savepoints if the underlying JDBC driver
+  supports savepoints.
+
+= Other New Features
+
+* A dataset_associations plugin has been added, allowing datasets
+  to call association methods, which return datasets of rows in
+  the associated table that are associated to rows in the current
+  dataset.
+
+    # Dataset of tracks from albums with name < 'M'
+    # by artists with name > 'M'
+
+    Artist.filter(:name > 'M').albums.filter(:name < 'M').tracks
+
+    # SELECT * FROM tracks
+    # WHERE (tracks.album_id IN (
+    #   SELECT albums.id FROM albums
+    #   WHERE ((albums.artist_id IN (
+    #     SELECT artists.id FROM artists
+    #     WHERE (name > 'M')))
+    #    AND (name < 'M'))))
+
+* Database#extend_datasets has been added, allowing you to do the
+  equivalent of extending all of the database's future datasets
+  with a module.  For performance, it creates an anonymous
+  subclass of the current dataset class and includes a module in
+  it, and uses the subclass to create future datasets.
+
+  Using this feature allows you to override any dataset method
+  and call super, similar to how Sequel::Model plugins work. The
+  method takes either a module:
+
+    Sequel.extension :columns_introspection
+    DB.extend_datasets(Sequel::ColumnsIntrospection)
+
+  or a block that it uses to create an anonymous module:
+
+    DB.extend_datasets do
+      # Always select from table.* instead of *
+      def from(*tables)
+        ds = super
+        if !@opts[:select] || @opts[:select].empty?
+          ds = ds.select_all(*tables)
+        end
+        ds
+      end
+    end
+
+* Database#<< and Dataset#<< now return self, which allow them
+  to be used in chaining:
+
+    DB << "UPADTE foo SET bar_id = NULL" << "DROP TABLE bars"
+    DB[:foo] << {:bar_id=>0} << DB[:bars].select(:id)
+
+* A Database#timezone accessor has been added, allowing you to
+  override Sequel.database_timezone on a per-Database basis, which
+  allows you to use two separate Database objects in the same
+  process that have different timezones.
+
+* You can now modify the type conversion procs on a per-Database
+  basis when using the mysql, sqlite, and ibmdb adapters, by
+  modifying the hash returned by Database#conversion_procs.
+
+* Model.dataset_module now accepts a Module instance as an argument,
+  and extends the model's dataset with that module.
+
+* When using the postgres adapter with the pg driver, you can now
+  use Database#listen to wait for notifications.  All adapters that
+  connect to postgres now support Database#notify to send
+  notifications:
+
+    # process 1
+    DB.listen('foo') do |ev, pid, payload|
+      ev # => 'foo'
+      notify_pid # => some Integer
+      payload # => 'bar'
+    end
+
+    # process 2
+    DB.notify('foo', :payload=>'bar')
+
+* many_to_one associations now have a :qualify option that can be set
+  to false to not qualify the primary key when loading the
+  association.  This shouldn't be necessary to use in most cases, but
+  in some cases qualifying a primary key breaks certain queries (e.g.
+  using JOIN USING on the same column on Oracle).
+
+* Database#schema can now take a dataset as an argument if it just
+  selects from a single table.  If a dataset is provided, the
+  schema parsing will use that dataset's identifier_input_method
+  and identifier_output_method for the parsing, instead of the
+  database's default.  This makes it possible for Model classes
+  to correctly get the table schema if they use a dataset whose
+  identifier_(input|output)_method differs from the database
+  default.
+
+* On databases that support common table expressions (CTEs) but do
+  not support CTE usage in subselects, Sequel now emulates support
+  by moving CTEs from the subselect to the main select when using
+  the Dataset from, from_self, with, with_recursive, union,
+  intersect, and except methods.
+
+* The bitwise compliment operator is now emulated on H2.
+
+* You can now set the convert_tinyint_to_bool setting on a
+  per-Database basis in the mysql and mysql2 adapters.
+
+* You can now set the convert_invalid_date_time setting on a
+  per-Database basis in the mysql adapter.
+
+* Database instances now have a dataset_class accessor that allows
+  you to set which class is used when creating datasets.  This is
+  mostly used to implement the extend_datasets support, but it
+  could be useful for other purposes.
+
+* Dataset#unused_table_alias now accepts an optional 2nd argument,
+  which should be an array of additional symbols that should be
+  considered as already used.
+
+* Dataset#requires_placeholder_type_specifiers? has been added to
+  check if the dataset requires you use type specifiers for
+  bound variable placeholders.
+
+  The prepared_statements plugin now checks this setting and works
+  correctly on adapters that set it to true, such as oracle.
+
+* Dataset#recursive_cte_requires_column_aliases? has been added
+  to check if you must provide a column list for a recursive CTE.
+
+  The rcte_tree plugin now checks this setting an works correctly
+  on databases that set it to true, such as Oracle and HSQLDB.
+
+= Performance Improvements
+
+* Numerous optimizations were made to loading model objects from
+  the database, resulting in a 7-16% speedup.
+
+  Model.call was added, and now .load is just an alias for .call.
+  This allows you to make the model dataset's row_proc the model
+  itself, instead of needing a separate block, which improves
+  performance.
+
+  While Model.load used to call .new (and therefore #initialize),
+  Model.call uses .allocate/#set_values/#after_initialize for speed.
+  This saves a method call or two, and skips setting the @new
+  instance variable.
+
+* Dataset#map, #to_hash, #select_map, #select_order_map, and
+  #select_hash are now faster if any of the provided arguments are
+  an array of symbols.
+
+* The Model.[] optimization is now applied in more cases.
+
+= Other Improvements
+
+* Sequel now creates accessor methods for all columns in a model's
+  table, even if the dataset doesn't select the columns.  This has
+  been the specified behavior for a while, but the spec was broken.
+  This allows you do to:
+
+    Model.dataset = DB[:table].select(:column1, :column2)
+    Model.select_more(:column3).first.column3
+
+* Model.def_dataset_method now correctly handles method names that
+  can't be used directly (such as method names with spaces).  This
+  isn't so the method can be used with arbitrary user input, but
+  it will allow safe creation of dataset methods that are derived
+  from column names, which could contain spaces.
+
+* Model.def_dataset_method no longer overrides private model
+  methods.
+
+* The optimization that Model.[] uses now works correctly if the
+  model's dataset uses a different identifier_input_method than
+  the database.
+
+* Sharding is supported correctly by default for the transactions
+  used by model objects.  Previously, you had to use the sharding
+  plugin to make sure the same shard was used for transactions as
+  for the insert/update/delete statements.
+
+* Sequel now fully supports using an aliased table for the
+  :join_table option of a many_to_many association.  The only real
+  use case for an aliased :join_table option is when the join table
+  is the same as the associated model table.
+
+* A bug when eagerly loading a many_through_many association with
+  composite keys where one of the join tables requires an alias
+  has been fixed.
+
+* Sequel's transaction internals have had substantial improvments.
+  You can now open up simultaneous transactions on two separate
+  shards of the same Database object in the same thread.  The new
+  design allows for future support of connection pools that aren't
+  based on threads.  Sequel no longer abuses thread-local variables
+  to store savepoint state.
+
+* Dataset#select_map and #select_order_map now return an array of
+  single element arrays if given an array with a single entry as
+  an argument.  Previously, they returned an array of values, which
+  wasn't consistent.
+
+* Sequel's emulation of bitwise operators with more than 2 arguments
+  now works on all adapters that use the emulation.  The emulation
+  was broken in 3.28.0 when more than 2 arguments were used on H2,
+  DB2, Microsoft SQL Server, PostgreSQL, and SQLite.
+
+* Dataset#columns now correctly handles the emulated offset support
+  used on DB2, Oracle, and Microsoft SQL Server when using the
+  jdbc, odbc, ado, and dbi adapters.  Previously, Dataet#columns
+  could contain the row number column, which wasn't in the
+  hashes yielded by Dataset#each.
+
+* Sequel can now parse primary key information on Microsoft SQL
+  Server.  Previously, the only adapter that supported this was the
+  jdbc adapter, which uses the generic JDBC support.  The shared
+  mssql adapter now supports parsing the information directly from
+  the database system tables.  This means that if you are using
+  Model objects with a Microsoft SQL Server database using the
+  tinytds, odbc, or ado adapters, the model primary key
+  information will be set automatically.
+
+* Sequel's prepared statement support no longer defines singleton
+  methods on the prepared statement objects.
+
+* StringMethods#like is now case sensitive on SQLite and Microsoft
+  SQL Server, making it more similar to other databases.
+
+* Sequel now works around an SQLite column naming bug if you select
+  columns qualified with the alias of a subselect without providing
+  an alias for the column itself.
+
+* Sequel now handles more bound variable types when using bound
+  variables outside of prepared statements on SQLite.
+
+* Sequel now works around a bug in certain versions of the
+  JDBC/SQLite driver when emulating alter table support for
+  operations such as drop_column.
+
+* Sequel now emulates the add_constraint and drop_constraint
+  alter table operations on SQLite, though the emulation has
+  issues.
+
+* Sequel now correctly handles composite primary keys when
+  emulating alter_table operations on SQLite.
+
+* Sequel now applies the correct PRAGMA statements by default when
+  connecting to SQLite via the amalgalite and swift adapters.
+
+* Sequel now supports using savepoints inside prepared transactions
+  on MySQL.
+
+* Sequel now closes JDBC ResultSet objects as soon as it is done
+  using them, leading to potentially lower memory usage in the JDBC
+  adapter, and fixes issues if you try to drop a table before
+  GC has collected a related ResultSet.
+
+* Sequel can now correctly insert all default values into a table
+  on DB2.  Before, this didn't work correctly if the table had more
+  than one column.
+
+* Another type of disconnection error is now recognized in the
+  mysql2 adapter.
+
+* Sequel now uses better error messages if you attempt to execute a
+  prepared statement without a name using the postgres, mysql, and
+  mysql2 adapters.
+
+* Some small fixes have been made that allow Sequel to run better
+  when $SAFE=1.  However, Sequel is not officially supported using
+  $SAFE > 0, so there could be many issues remaining.
+
+* Sequel's core and model specs were cleaned up by using the mock
+  adapter to eliminate a lot of redundant code.
+
+* Sequel's integration tests were sped up considerably, halving
+  the execution time on some adapters.
+
+= Backwards Compatibility
+
+* Because Model.load is now an alias for .call, plugins should no
+  longer override load.  Instead, they should override .call.
+
+* Loading model objects from the database no longer calls
+  Model#initialize.  Instead, it calls Model.allocate,
+  Model#set_values, and Model#after_initialize.  So if you were
+  overriding #initialize and expecting the changes to affect model
+  objects loaded from the database, you need to change your code.
+
+  Additionally, @new is no longer set to false for objects retieved
+  from the database, since setting it to false hurts performance.
+  Model#new? still returns true or false, so this only affects you
+  if you are checking the instance variables directly.
+
+* Dataset#<< no longer returns the autogenerated primary key for the
+  inserted row.  As mentioned above, it now returns self to allow for
+  chaining.  If you were previously relying on the return value,
+  switch from #<< to #insert.
+
+* Dataset#map no longer calls the row_proc if given an argument, and
+  Dataset#to_hash no longer calls the row_proc if given two arguments.
+  This should only affect your code if you were using a row_proc that
+  modified the content of the hash (e.g. Model#after_initialize). If
+  you were relying on the old behavior, switch:
+
+    dataset.map(:foo)
+    # to
+    dataset.map{|r| r[:foo]}
+
+    dataset.to_hash(:foo, :bar)
+    # to
+    h = {}
+    dataset.each{|r| h[r[:foo]] = r[:bar]}
+    h
+
+* Model classes now need to have a dataset before you can define
+  associations on them.
+
+* Model classes now pass their dataset to Database#schema, instead of
+  their table name.
+
+* The :eager_block association option (which defaults to the
+  association's block argument) is now called before the :eager_graph
+  association option has been applied, instead of after.
+
+* The many_to_many association reflection :qualified_right_key entry
+  is now a method named qualified_right_key.  Switch any
+  code using association_reflection[:qualified_right_key] to use
+  association_reflection.qualified_right_key.
+
+* If you are using like on SQLite and Microsoft SQL Server and want
+  it to be case insensitive, switch to using ilike:
+
+    # Case sensitive
+    DB[:foos].where(:name.like('bar%'))
+    # Case insensitive
+    DB[:foos].where(:name.ilike('bar%'))    
+
+  Sequel now sets the case_sensitive_like PRAGMA to true by default
+  on SQLite.  To set it to false instead, pass the
+  :case_sensitive_like=>false option to the database when creating it.
+
+* Sequel's alter table emulation on SQLite now renames the current
+  table then populates the replacement table, instead of
+  populating the replacement table at a temporary name, dropping
+  the current table, and then renaming the replacement table.
+
+* The strings 'n' and 'no' (case insensitive) when typecasted to
+  boolean are now considered false values instead of true.
+
+* The transaction internals had extensive changes, if you have any
+  code that depended on the transaction internals, it will probably
+  require changes.
+
+* Using the Sequel::MySQL module settings for convert_tinyint_to_bool
+  and convert_invalid_date_time now only affects future Database
+  objects.  You should switch to using the per-Database methods
+  if you are currently using the Sequel::MySQL module methods.
+
+* The customized transaction support in the do (DataObjects) adapter
+  was removed.  All three subadapters (postgres, mysql, sqlite) of
+  the do adapter implement their own transaction support, so this
+  should have no effect unless you were using the do adapter with
+  a different database type.
+
+* The oracle support changed dramatically, so if you were relying
+  on the internals of the oracle support, you should take extra
+  care when upgrading.
+
+= Advance Notice
+
+* The next release of Sequel will contain significant changes to
+  how a dataset is literalized into an SQL string.  If you have
+  a custom plugin, extension, or adapter that overrides a
+  method containing "literal", "sql", or "quote", or you make
+  other modifications or extensions to how Sequel currently
+  literalizes datasets to SQL, your code will likely need to
+  be modified to support the next release.