sequel 3.33.0 → 3.34.0

data/CHANGELOG

@@ -1,3 +1,143 @@
+=== 3.34.0 (2012-04-02)
+
+* Fix connection failures when connecting to PostgreSQL with newer versions of swift (jeremyevans)
+
+* Fix using a bound variable for a limit in the ibmdb adapter on ruby 1.9 (jeremyevans)
+
+* primary_key :column, :type=>Bignum now works correctly on H2 (jeremyevans)
+
+* Add query_literals extension for treating regular strings like literal strings in select, group, and order methods (jeremyevans)
+
+* Actually use RETURNING for deletes/updates on PostgreSQL 8.2-9.0 (jeremyevans)
+
+* You can now require 'sequel/no_core_ext' to load Sequel without the core extensions (jeremyevans)
+
+* The core extensions have now been made a real Sequel extension (still loaded by default) (jeremyevans)
+
+* VirtualRow#` has been added for creating literal strings (jeremyevans)
+
+* VirtualRow instances now have operator methods defined {+,-,*,/,&,|,~,>,<,>=,<=} (jeremyevans)
+
+* Array#all_two_pairs? is now deprecated and will be removed after 3.34.0 is released (jeremyevans)
+
+* All of Sequel's core extensions now have equivalent methods defined on the Sequel module (jeremyevans)
+
+* Add Sequel.core_extensions? for checking if the core extensions are enabled (jeremyevans)
+
+* Increase speed of Model#this by about 85% (jeremyevans)
+
+* Increase speed of Model#delete and #destroy by about 75% for models with simple datasets (jeremyevans)
+
+* Make nested_attributes plugin work when destroying/removing associated objects when strict_param_setting is true (r-stu31) (#455)
+
+* Dataset#disable_insert_returning on PostgreSQL is now deprecated and will be removed after 3.34.0 is released (jeremyevans)
+
+* Double speed of Model[pk] for models with simple datasets (most models) (jeremyevans)
+
+* Support for ruby <1.8.7 and PostgreSQL <8.2 is now deprecated and will be removed after 3.34.0 is released (jeremyevans)
+
+* Add select_remove extension which adds Dataset#select_remove for removing columns/expressions from a dataset selection (jeremyevans)
+
+* Add static_cache plugin, for staticly caching all model instances, useful for model tables that don't change (jeremyevans)
+
+* Add Model#freeze implementation to get a working frozen model object (jeremyevans)
+
+* Add many_to_one_pk_lookup plugin, for using a simple primary key lookup for many_to_one associations (great with caching) (jeremyevans)
+
+* Use bigint type instead of integer for Bignum generic type on SQLite, except for auto incrementing primary keys (jeremyevans)
+
+* Add Database#dump_foreign_key_migration for just dumping foreign key constraints to the schema dumper extension (jeremyevans)
+
+* Dump foreign key constraints by default when using the schema dumper extension (jeremyevans)
+
+* Don't raise an error when no indexes exist for a table when calling Database#indexes on the jdbc/sqlite adapter (jeremyevans)
+
+* Copy composite foreign key constraints when emulating alter_table on SQLite (jeremyevans)
+
+* Add Database#foreign_key_list for getting foreign key metadata for a given table on SQLite, MySQL, and PostgreSQL (jeremyevans)
+
+* Add Dataset#to_hash_groups and #select_hash_groups for getting a hash with arrays of matching values (jeremyevans)
+
+* Model#set_fields and #update_fields now respect :missing=>:skip and :missing=>:raise options for handling missing values (jeremyevans)
+
+* The :on_update and :on_delete entries for foreign key can now take strings, which are used literally (jeremyevans)
+
+* Add Database#convert_infinite_timestamps to the postgres adapter, can be set to :nil, :string, or :float (jeremyevans) (#454)
+
+* Add Database#create_join_table and #drop_join_table for easily creating many-to-many join tables (jeremyevans)
+
+* Fix Dataset#group_rollup/#group_cube on Microsoft SQL Server 2005 (jeremyevans)
+
+* Add Dataset#explain on MySQL (jeremyevans)
+
+* Change formatting and return value of Dataset#explain on SQLite (jeremyevans)
+
+* Recognize unsigned tinyint types in the schema dumper (jeremyevans)
+
+* Add null_dataset extension, for creating a dataset that never issues a database query (jeremyevans)
+
+* Database#uri and #url now return nil if a connection string was not used when connecting (jeremyevans) (#453)
+
+* Add schema_caching extension, to speed up loading a large number of models by loading cached schema information from a file (jeremyevans)
+
+* Add Dataset#multi_replace on MySQL, allowing you to REPLACE multiple rows in a single query (danielb2) (#452)
+
+* Double speed of Model#new with empty hash, and quadruple speed of Model#set with empty hash (jeremyevans)
+
+* Allow SQL::QualifiedIdentifier objects to contain arbitrary Sequel expressions (jeremyevans)
+
+* Add pg_hstore_ops extension, for easily calling PostgreSQL hstore functions and operators (jeremyevans)
+
+* Add Sequel::SQL::Wrapper class for easier dealing with wrapper objects (jeremyevans)
+
+* Add pg_hstore extension, for dealing with the PostgreSQL hstore (key/value table) type (jeremyevans)
+
+* Add Database#type_supported? method on PostgreSQL for checking if the given type symbol/string is supported (jeremyevans)
+
+* Convert Java::OrgPostgresqlUtil::PGobject instances to ruby strings in jdbc/postgres type conversion (jeremyevans)
+
+* Allow PlaceholderLiteralString objects to store placeholder string as an array for improved performance (jeremyevans)
+
+* Work around ruby-pg bugs 111 (Time/DateTime fractional seconds) and 112 ("\0" in bytea) in bound variable arguments (jeremyevans) (#450)
+
+* Handle fractional seconds correctly for time type on jdbc/postgres (jeremyevans)
+
+* Add pg_array_ops extension, for easily calling PostgreSQL array functions and operators (jeremyevans)
+
+* Add SQL::Subscript#[] for using nested subscripts (accessing member of multi-dimensional array) (jeremyevans)
+
+* Add Model.cache_anonymous_models accessor so you can disable the caching of classes created by Sequel::Model() (jeremyevans)
+
+* Convert PostgreSQL JDBC arrays to Ruby arrays in the jdbc/postgres adapter (jeremyevans)
+
+* The typecast_on_load extension now works correctly when saving new model objects when insert_select is enabled (jeremyevans)
+
+* Add pg_array extension, for dealing with string and numeric PostgreSQL arrays (jeremyevans)
+
+* Add Database#reset_conversion_procs to the postgres adapter, for use with extensions with modify default conversion procs (jeremyevans)
+
+* Escape table and schema names when getting primary key or sequence information on PostgreSQL (jeremyevans)
+
+* Escape identifiers when quoting on MySQL and SQLite (jeremyevans)
+
+* Add Database#supports_drop_table_if_exists? for checking if DROP TABLE supports IF EXISTS (jeremyevans)
+
+* Add Database#drop_table? for dropping a table if it already exists (jeremyevans)
+
+* Log full SQL string by default for prepared statements created automatically by model prepared_statements* plugins (jeremyevans)
+
+* Add ability for prepared statements to log full SQL string (jeremyevans)
+
+* Add pg_statement_cache extension, for automatically preparing queries when using postgres adapter with pg driver (jeremyevans)
+
+* Add pg_auto_parameterize extension, for automatically parameterizing queries when using postgres adapter with pg driver (jeremyevans)
+
+* Add ConnectionPool#disconnection_proc= method, to modify disconnection_proc after the pool has been created (jeremyevans)
+
+* Add ConnectionPool#after_connect= method, to modify after_connect proc after the pool has been created (jeremyevans)
+
+* Add ConnectionPool#all_connections method, which yields all available connections in the pool (jeremyevans)
+
 === 3.33.0 (2012-03-01)
 
 * Add ability to force or disable transactions completely in the migrators using the :use_transactions option (jeremyevans)

data/Rakefile

@@ -139,12 +139,19 @@ begin
   spec_with_cov.call("spec", Dir["spec/{core,model}/*_spec.rb"], "Run core and model specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/adapters/([a-ln-z]|m[a-np-z])"')}
   spec.call("spec_core", Dir["spec/core/*_spec.rb"], "Run core specs")
   spec.call("spec_model", Dir["spec/model/*_spec.rb"], "Run model specs")
+  spec.call("_spec_model_no_assoc", Dir["spec/model/*_spec.rb"].delete_if{|f| f =~ /association|eager_loading/}, '')
   spec_with_cov.call("spec_plugin", Dir["spec/extensions/*_spec.rb"], "Run extension/plugin specs")
   spec_with_cov.call("spec_integration", Dir["spec/integration/*_test.rb"], "Run integration tests")
   
   %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")
   end
+
+  desc "Run model specs without the associations code"
+  task :spec_model_no_assoc do
+    ENV['SEQUEL_NO_ASSOCIATIONS'] = '1'
+    Rake::Task['_spec_model_no_assoc'].invoke
+  end
 rescue LoadError
   task :default do
     puts "Must install rspec to run the default task (which runs specs)"

data/bin/sequel

@@ -7,6 +7,7 @@ require 'sequel'
 db_opts = {:test=>true}
 copy_databases = nil
 dump_migration = nil
+dump_schema = nil
 echo = nil
 env = nil
 logfile = nil
@@ -14,6 +15,7 @@ migrate_dir = nil
 migrate_ver = nil
 backtrace = nil
 load_dirs = []
+exclusive_options = []
 
 opts = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
@@ -39,10 +41,12 @@ opts = OptionParser.new do |opts|
   
   opts.on("-d", "--dump-migration", "print database migration to STDOUT") do 
     dump_migration = true
+    exclusive_options << :d
   end
   
   opts.on("-D", "--dump-migration-same-db", "print database migration to STDOUT without type translation") do
     dump_migration = :same_db
+    exclusive_options << :D
   end
 
   opts.on("-e", "--env ENV", "use environment config for database") do |v|
@@ -67,6 +71,7 @@ opts = OptionParser.new do |opts|
   
   opts.on("-m", "--migrate-directory DIR", "run the migrations in directory") do |v|
     migrate_dir = v
+    exclusive_options << :m
   end
   
   opts.on("-M", "--migrate-version VER", "migrate the database to version given") do |v|
@@ -81,6 +86,11 @@ opts = OptionParser.new do |opts|
     load_dirs << [v]
   end
 
+  opts.on("-S", "--dump-schema filename", "dump the schema for all tables to the file") do |v|
+    dump_schema = v
+    exclusive_options << :S
+  end
+
   opts.on("-t", "--trace", "Output the full backtrace if an exception is raised") do
     backtrace = true
   end
@@ -100,8 +110,7 @@ error_proc = lambda do |msg|
 end
 
 error_proc["Error: Must specify -m if using -M"] if migrate_ver && !migrate_dir
-error_proc["Error: Cannot specify -D or -d with -m"] if dump_migration && migrate_dir
-error_proc["Error: Cannot specify -C with -d, -D, or -m"] if copy_databases && (dump_migration || 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'
@@ -139,6 +148,12 @@ begin
     puts DB.dump_schema_migration(:same_db=>dump_migration==:same_db)
     exit
   end
+  if dump_schema
+    Sequel.extension :schema_caching
+    DB.tables.each{|t| DB.schema(Sequel::SQL::Identifier.new(t))}
+    DB.dump_schema_cache(dump_schema)
+    exit
+  end
   if copy_databases
     Sequel.extension :migration, :schema_dumper
 
@@ -151,6 +166,7 @@ begin
     puts "Databases connections successful"
     schema_migration = eval(DB.dump_schema_migration(:indexes=>false, :same_db=>same_db))
     index_migration = eval(DB.dump_indexes_migration(:same_db=>same_db))
+    fk_migration = eval(DB.dump_foreign_key_migration(:same_db=>same_db))
     puts "Migrations dumped successfully"
 
     schema_migration.apply(TO_DB, :up)
@@ -182,6 +198,10 @@ begin
     index_migration.apply(TO_DB, :up)
     puts "Finished creating indexes"
 
+    puts "Begin adding foreign key constraints"
+    fk_migration.apply(TO_DB, :up)
+    puts "Finished adding foreign key constraints"
+
     if TO_DB.database_type == :postgres
       TO_DB.tables.each{|t| TO_DB.reset_primary_key_sequence(t)}
       puts "Primary key sequences reset successfully"

data/doc/dataset_basics.rdoc

@@ -93,7 +93,7 @@ other:: clone, distinct, naked, server, with_sql
 
 Most other dataset methods commonly used will execute the dataset's SQL on the database:
 
-SELECT (All Records):: all, each, map, to_hash, select_map, select_order_map, select_hash, to_csv
+SELECT (All Records):: all, each, map, to_hash, to_hash_groups, select_map, select_order_map, select_hash, select_hash_groups, to_csv
 SELECT (First Record):: first, last, get, []
 SELECT (Aggregates):: count, avg, max, min, sum, range, interval
 INSERT:: insert, <<, import, multi_insert, insert_multiple

data/doc/mass_assignment.rdoc

@@ -36,7 +36,7 @@ By default, if an invalid setter method call is attempted, Sequel raises a <tt>S
   # Instance level
   post.strict_param_setting = false
 
-These mass assignment methods have been around a long time, but starting in Sequel 3.12.0, the +set_fields+ or +update_fields+ methods were added, and these may be a better mass assignment choice for most users.
+These mass assignment methods have been around a long time, but starting in Sequel 3.12.0, the +set_fields+ and +update_fields+ methods were added, and these may be a better mass assignment choice for most users.
 These methods take two arguments, the attributes hash as the first argument, and a single array of valid field names as the second argument:
 
   post.set_fields(params[:post], [:title, :body])
@@ -50,5 +50,7 @@ They work great for things like HTML forms where the form fields are static.
 +set_only+ and +update_only+ are designed for cases where you are not sure what fields are going to be present in the input, but still want to make sure only certain setter methods can be called.
 They work great for flexible APIs.
 
+Starting in Sequel 3.34.0, +set_fields+ and +update_fields+ take an optional argument hash, and currently handles the :missing option.  With <tt>:missing=>:skip</tt>, +set_fields+ and +update_fields+ will just skip missing entries in the hash, allowing them to be used in flexible APIs.  With <tt>:missing=>:raise</tt>, +set_fields+ and +update_fields+ will raise an error if one of the entries in the hash is missing, instead of just assigning the value to nil or whatever the hash's default value is.  That allows stricter checks, similar to the :strict_param_checking setting for the default mass assignment methods.
+
 In all of the mass assignment cases, methods starting with +set+ will set the attributes without saving the object, while methods starting with +update+ will set the attributes and then save the changes to the object.
 

data/doc/querying.rdoc

@@ -167,17 +167,26 @@ It's also common to want to order such a map, so Sequel provides a
 Sequel makes it easy to take an SQL query and return it as a ruby hash,
 using the +to_hash+ method:
 
-  artist_names = Artist.to_hash(:name, :id)
+  artist_names = Artist.to_hash(:id, :name)
   # SELECT * FROM artists
-  => {"YJM"=>1, "AS"=>2}
+  => {1=>"YJM", 2=>"AS"}
 
 As you can see, the +to_hash+ method uses the first symbol as the key
 and the second symbol as the value.  So if you swap the two arguments the hash
 will have its keys and values transposed:
 
-  artist_names = Artist.to_hash(:id, :name)
+  artist_names = Artist.to_hash(:name, :id)
   # SELECT * FROM artists
-  => {1=>"YJM", 2=>"AS"}
+  => {"YJM"=>1, "AS"=>2}
+
+Now what if you have multiple values for the same key?  By default, +to_hash+
+will just have the last matching value.  If you care about all matching values,
+use +to_hash_groups+, which makes the values of the array an array of matching
+values, in the order they were received:
+
+  artist_names = Artist.to_hash_groups(:name, :id)
+  # SELECT * FROM artists
+  => {"YJM"=>[1, 10, ...], "AS"=>[2, 20, ...]}
 
 If you only provide one argument to +to_hash+, it uses the entire hash
 or model object as the value:
@@ -186,6 +195,12 @@ or model object as the value:
   # SELECT * FROM artists
   => {"YJM"=>{:id=>1, :name=>"YJM"}, "AS"=>{:id=>2, :name=>"AS"}}
 
+and +to_hash_groups+ works similarly:
+
+  artist_names = DB[:artists].to_hash_groups(:name)
+  # SELECT * FROM artists
+  => {"YJM"=>[{:id=>1, :name=>"YJM"}, {:id=>10, :name=>"YJM"}], ...}
+
 Model datasets have a +to_hash+ method that can be called without any
 arguments, in which case it will use the primary key as the key and
 the model object as the value.  This can be used to easily create an
@@ -196,6 +211,9 @@ identity map:
   => {1=>#<Artist @values={:id=>1, :name=>"YGM"}>,
       2=>#<Artist @values={:id=>2, :name=>"AS"}>}
 
+There is no equivalent handling to +to_hash_groups+, since there would
+only be one matching record, as the primary key must be unique.
+
 Note that +to_hash+ never modifies the columns selected.  However, just
 like Sequel has a +select_map+ method to modify the columns selected and
 return an array, Sequel also has a +select_hash+ method to modify the
@@ -205,6 +223,12 @@ columns selected and return a hash:
   # SELECT name, id FROM artists
   => {"YJM"=>1, "AS"=>2}
 
+Likewise, +select_hash_groups+ also exists:
+
+  artist_names = Artist.select_hash_groups(:name, :id)
+  # SELECT name, id FROM artists
+  => {"YJM"=>[1, 10, ...], "AS"=>[2, 20, ...]}
+
 == Modifying datasets 
 
 Note that the retrieval methods discussed above just return

data/doc/reflection.rdoc

@@ -4,9 +4,9 @@ Sequel supports reflection information in multiple ways.
 
 == Adapter in Use
 
-You can get the adapter in use using Database.adapter_scheme.  As this is a class method, you generally need to do DB.class.adapter_scheme:
+You can get the adapter in use using Database#adapter_scheme:
 
-  DB.class.adapter_scheme # e.g. :postgres, :jdbc, :odbc
+  DB.adapter_scheme # e.g. :postgres, :jdbc, :odbc
 
 == Database Connected To
 
@@ -24,7 +24,7 @@ Database#tables gives an array of table name symbols:
 
 Database#views and gives an array of view name symbols:
 
-  DB.tables # [:table1, :table2, :table3, ...]
+  DB.views # [:view1, :view2, :view3, ...]
 
 == Indexes on a table
 
@@ -34,6 +34,26 @@ Database#indexes takes a table name gives a hash of index information.  Keys are
 
 Index information generally does not include partial indexes, functional indexes, or indexes on the primary key of the table.
 
+== Foreign Key Information for a Table
+
+Database#foreign_key_list takes a table name and gives an array of hashes of foreign key information:
+
+  DB.foreign_key_list(:table1) # [{:columns=>[:column1], :table=>:referenced_table, :key=>[:referenced_column1]}]
+
+At least the following entries will be present in the hash:
+
+:columns :: An array of columns in the given table
+:table :: The table referenced by the columns
+:key :: An array of columns referenced (in the table specified by :table), but can be nil on certain adapters
+        if the primary key is referenced.
+
+The hash may also contain entries for:
+
+:deferrable :: Whether the constraint is deferrable
+:name :: The name of the constraint
+:on_delete :: The action to take ON DELETE
+:on_update :: The action to take ON UPDATE
+
 == Column Information for a Table
 
 Database#schema takes a table symbol and returns column information in an array with each element being an array with two elements.  The first elements of the subarray is a column symbol, and the second element is a hash of information about that column.  The hash should include the following keys:

data/doc/release_notes/3.34.0.txt

@@ -0,0 +1,671 @@
+= New PostgreSQL Extensions
+
+* A pg_array extension has been added, supporting PostgreSQL's
+  numeric and string array types.  Both single dimensional and
+  multi-dimensional array types are supported.  Array values are
+  returned as instances of Sequel::Postgres::PGArray, which is a
+  delegate class of Array.  You can turn an existing array into
+  a PGArray using Array#pg_array.
+
+  If you are using arrays in model objects, you need to load
+  support for that:
+
+    DB.extend Sequel::Postgres::PGArray::DatabaseMethods
+
+  This makes schema parsing and typecasting of array columns work
+  correctly.
+
+  This extension also allows you to use PGArray objects and arrays
+  in bound variables when using the postgres adapter with pg.
+
+* A pg_hstore extension has been added, supporting PostgreSQL's hstore
+  type, which is a simple hash with string keys and string or NULL
+  values.  hstore values are retrieved as instances of
+  Sequel::Postgres::HStore, which is a delegate class of Hash.  You
+  can turn an existing hash into an hstore using Hash#hstore.
+
+  If you are using hstores in model objects, you need to load
+  support for that:
+
+    DB.extend Sequel::Postgres::HStore::DatabaseMethods
+
+  This makes schema parsing and typecasting of hstore columns work
+  correctly.
+
+  This extension also allows you to use HStore objects and hashes
+  in bound variables when using the postgres adapter with pg.
+
+* A pg_array_ops extension has been added, making it easier to call
+  PostgreSQL array operators and functions using plain ruby code.
+  Examples:
+
+    a = :array_column.pg_array
+    a[1]              # array_column[1]
+    a[1][2]           # array_column[1][2]
+    a.push(1)         # array_column || 1
+    a.unshift(1)      # 1 || array_column
+    a.any             # ANY(array_column)
+    a.join            # array_to_string(array_column, '', NULL)
+
+  If you are also using the pg_array extension, you can turn
+  a PGArray object into a query object, which allows you to run
+  operations on array literals:
+
+    a = [1, 2].pg_array.op
+    a.push(3)               # ARRAY[1,2] || 3
+
+* A pg_hstore_ops extension has been added, making it easier to call
+  PostgreSQL hstore operators and functions using plain ruby code.
+  Examples:
+
+    h = :hstore_column.hstore
+    h['a']             # hstore_column -> 'a'
+    h.has_key?('a')    # hstore_column ? 'a'
+    h.keys             # akeys(hstore_column)
+    h.to_array         # hstore_to_array(hstore_column)
+
+  If you are also using the pg_hstore extension, you can turn
+  an HStore object into a query object, which allows you to run
+  operations on hstore literals:
+
+    h = {'a' => 'b'}.hstore.op
+    h[a]               # '"a"=>"b"'::hstore -> 'a'
+
+* A pg_auto_parameterize extension has been added for automatically
+  using bound variables for all queries.  For example, it can take
+  code such as:
+
+    DB[:table].where(:column=>1)
+  
+  and do:
+
+    SELECT * FROM table WHERE column = $1; -- [1]
+
+  Note that automatically parameterizing queries is not generally
+  faster unless the bound variables are large (i.e. long text/bytea
+  values).  Also, there are multiple corner cases when automatically
+  parameterizing queries, though most can be worked around by
+  adding explicit casts.
+
+* A pg_statement_cache extension has been added that works with the
+  pg_auto_parameterize extension for automatically caching prepared
+  statements and reusing them when using the postgres adapter with
+  pg.  The combination of these two extensions makes it possible to
+  take an entire Sequel application and turn most or all of the
+  queries into prepared statements.
+
+  Note that these two extensions do not necessarily improve
+  performance.  For simple queries, they actually hurt performance.
+  They do help for complex queries, but in all cases, it's faster
+  to use Sequel's prepared statements API manually.
+
+= Other New Extensions
+
+* A query_literals extension has been added that makes the select,
+  group, and order methods operate similar to the filter methods in
+  that if they are given a regular string as their first argument,
+  they treat it as a literal string, with additional arguments, if
+  any, used as placeholder values.  This extension allows you to
+  write code such as:
+
+    DB[:table].select('a, b, ?' 2).group('a, b').order('c')
+    # Without query_literals:
+    #   SELECT 'a, b, ?', 2 FROM table GROUP BY 'a, b' ORDER BY 'c'
+    # With query_literals:
+    #   SELECT a, b, 2 FROM table GROUP BY a, b ORDER BY c
+
+  Sequel's default handling in this case is to use literal strings,
+  which is generally not desired and on some databases not even
+  valid syntax.  In general, you'll probably want to use this
+  extension for all of a database's datasets, which you can do via:
+
+    Sequel.extension :query_literals
+    DB.extend_datasets(Sequel::QueryLiterals)
+
+  The next major version of Sequel (4.0.0) will probably integrate
+  this extension into the core library.
+
+* A select_remove extension has been added that adds
+  Dataset#select_remove, for removing selected columns/expressions
+  from a dataset:
+
+    ds = DB[:table]
+    # Assume table has columns a, b, and c
+
+    ds.select_remove(:c)
+    # SELECT a, b FROM table
+
+    # Removal by column alias
+    ds.select(:a, :b___c, :c___b).select_remove(:c)
+    # SELECT a, c AS b FROM table 
+    
+    # Removal by expression
+    ds.select(:a, :b___c, :c___b).select_remove(:c___b)
+    # SELECT a, b AS c FROM table 
+    
+  This method makes it easier to select all columns except for the
+  columns given.  This is common in cases where a table has a few
+  large columns that are expensive to retrieve.  This method does
+  have some corner cases, so read the documentation before using it.
+
+* A schema_caching extension has added that makes it possible for
+  Database instances to dump the cached schema metadata to a
+  marshalled file, and load the cached schema metadata from the file.
+  This can be significantly faster than reparsing the schema from the
+  database, especially for databases with high latency.
+
+  bin/sequel -S has been added to dump the schema for the given
+  database to a file, and DB.load_schema_cache(filename) can be used
+  to populate the schema cache inside your application.  This should
+  be done after creating the Database object but before loading your
+  model files.
+
+  Note that Sequel does no checking to ensure that the cached schema
+  currently reflects the state of the database.  That is up to the
+  application.
+
+* A null_dataset extension has been added, which adds
+  Dataset#nullify for creating a dataset that will not issue a
+  database query.  It implements the null object pattern for
+  datasets, and is probably most useful in methods that must return
+  a dataset, but can determine that such a dataset will never return
+  a row.
+
+= New Plugins
+
+* A static_cache plugin has been added, allowing you to cache a model
+  statically.  This plugin is useful for models whose tables do not
+  change while the application is running, such as lookup tables.
+  When using this plugin, the following methods will no longer require
+  queries:
+
+  * Primary key lookups (e.g. Model[1])
+  * Model.all calls
+  * Model.each calls
+  * Model.map calls without an argument
+  * Model.to_hash calls without an argument
+
+  The statically cached model instances are frozen so they are not
+  accidently modified.
+
+* A many_to_one_pk_lookup plugin has been added that changes the
+  many_to_one association retrieval code to do a simple primary
+  key lookup on the associated class in most cases.  This results
+  in significantly better performance, especially if the
+  associated model is using a caching plugin (either caching
+  or static_cache).
+
+= Core Extension Replacements
+
+* Most of Sequel's core extensions now have equivalent methods defined
+  on the Sequel module:
+
+    :column.as(:alias)        -> Sequel.as(:column, :alias)   
+    :column.asc               -> Sequel.asc(:column)
+    :column.desc              -> Sequel.desc(:column)
+    :column.cast(Integer)     -> Sequel.cast(:column, Integer)
+    :column.cast_numeric      -> Sequel.cast_numeric(:column)
+    :column.cast_string       -> Sequel.cast_string(:column)
+    :column.extract(:year)    -> Sequel.extract(:year, :column)
+    :column.identifier        -> Sequel.identifier(:column)
+    :column.ilike('A%')       -> Sequel.ilike(:column, 'A%')
+    :column.like('A%')        -> Sequel.like(:column, 'A%')
+    :column.qualify(:table)   -> Sequel.qualify(:table, :column)
+    :column.sql_subscript(1)  -> Sequel.subscript(:column, 1)
+    :function.sql_function(1) -> Sequel.function(:function, 1)
+    'some SQL'.lit            -> Sequel.lit('some SQL')
+    'string'.to_sequel_blob   -> Sequel.blob('string')
+    {:a=>1}.case(0)           -> Sequel.case({:a=>1}, 0)
+    {:a=>1}.sql_negate        -> Sequel.negate(:a=>1)
+    {:a=>1}.sql_or            -> Sequel.or(:a=>1)
+    [[1, 2]].sql_value_list   -> Sequel.value_list([[1, 2]])
+    [:a, :b].sql_string_join  -> Sequel.join([:a, :b])
+    ~{:a=>1}                  -> Sequel.~(:a=>1)
+    :a + 1                    -> Sequel.+(:a, 1)
+    :a - 1                    -> Sequel.-(:a, 1)
+    :a * 1                    -> Sequel.*(:a, 1)
+    :a / 1                    -> Sequel./(:a, 1)
+    :a & 1                    -> Sequel.&(:a, 1)
+    :a | 1                    -> Sequel.|(:a, 1)
+
+* You can now wrap any object in a Sequel expression using
+  Sequel.expr.  This is similar to the sql_expr extension, but
+  without defining the sql_expr method on all objects:
+
+    1.sql_expr                -> Sequel.expr(1)
+
+  The sql_expr extension now just has Object#sql_expr call
+  Sequel.expr.
+
+* Virtual Rows now have methods defined that handle the standard
+  mathematical operators:
+
+    select{|o| o.+(1, :a)} # SELECT (1 + a)
+
+  the standard inequality operators:
+
+    where{|o| o.>(2, :a)}  # WHERE (2 > a)
+
+  and the standard boolean operators:
+
+    where{|o| o.&({:a=>1}, o.~(:b=>1))} # WHERE ((a = 1) AND (b != 1))
+
+  Additionally, there is now direct support for creating literal
+  strings in instance_evaled virtual row blocks using `:
+
+    where{a > `some crazy SQL`} # WHERE (a > some crazy SQL)
+
+  This doesn't override Kernel.`, since virtual rows use a BasicObject
+  subclass.  Previously, using ` would result in calling the SQL
+  function named ` with the given string, which probably isn't valid
+  syntax on most databases.
+
+* You can now require 'sequel/no_core_ext' to load Sequel without the
+  core extensions.  The previous way of setting the
+  SEQUEL_NO_CORE_EXTENSIONS constant or environment variable before
+  loading Sequel still works.
+
+* The core extensions have been moved from Sequel's core library into
+  an extension that is loadable with Sequel.extension.  This extension
+  is still loaded by default for backwards compatibility.  However,
+  the next major version of Sequel will no longer load this extension
+  by default (though it will still be available to load manually).
+
+* You can now check if the core extensions have been loaded by using
+  Sequel.core_extensions?.
+
+= Foreign Keys in the Schema Dumper
+
+* Database#foreign_key_list has been added that gives an array of
+  foreign key constraints on the table.  It is currently implemented
+  on MySQL, PostgreSQL, and SQLite, and may be implemented on other
+  database types in the future.  Each entry in the return array is
+  a hash, with at least the following keys present:
+
+  :columns :: An array of columns in the given table
+  :table :: The table referenced by the columns
+  :key :: An array of columns referenced (in the table specified by
+          :table), but can be nil on certain adapters if the primary
+          key is referenced.
+
+  The hash may also contain entries for:
+
+  :deferrable :: Whether the constraint is deferrable
+  :name :: The name of the constraint
+  :on_delete :: The action to take ON DELETE
+  :on_update :: The action to take ON UPDATE
+
+* The schema_dumper extension now dumps foreign key constraints on
+  databases that support Database#foreign_key_list.  On such
+  databases, dumping a schema migration will dump the tables in
+  topological order, such that referenced tables always come before
+  referencing tables.
+
+  In case there is a circular dependency, Sequel breaks the
+  dependency and adds separate foreign key constraints at the end
+  of the migration.  However, when a circular dependency is broken,
+  the migration can probably not be migrated down.
+
+  Foreign key constraints can also be dumped as a separate migration
+  using Database#dump_foreign_key_migration, similar to how
+  Database#dump_indexes_migration works.
+
+* When using bin/sequel -C to copy databases, foreign key constraints
+  are now copied if the source database supports
+  Database#foreign_key_list.
+
+= Other New Features
+
+* Dataset#to_hash_groups and #select_hash_groups have been added.
+  These methods are similar to #to_hash and #select_hash in that they
+  return a hash, but hashes returned by *_hash_groups methods have
+  arrays of all matching values, unlike the *_hash methods which
+  just use the last matching value. Example:
+
+    DB[:table].all
+    # => [{:a=>1, :b=>2}, {:a=>1, :b=>3}, {:a=>2, :b=>4}]
+
+    DB[:table].to_hash(:a, :b)
+    # => {1=>3, 2=>4}
+
+    DB[:table].to_hash_groups(:a, :b)
+    # => {1=>[2, 3], 2=>[4]}
+
+* Model#set_fields and #update_fields now accept :missing=>:skip and
+  :missing=>:raise options, allowing them to be used in more cases.
+  :missing=>:skip skips missing entries in the hash, instead of
+  setting the field to the default hash value.  :missing=>:raise
+  raises an error for missing fields, similar to
+  strict_param_setting = true.  It's recommended that these options
+  be used in new code in preference to #set_only and #update_only.
+
+* Database#drop_table? has been added, for dropping tables if they
+  already exist.  This uses DROP TABLE IF EXISTS on the databases that
+  support it.  Database#supports_drop_table_if_exists? has been added
+  for checking whether the database supports that syntax.
+
+* Database#create_join_table has been added that allows easy 
+  creation of many_to_many join tables:
+
+    DB.create_join_table(:album_id=>:albums, :artist_id=>:artists)
+
+  This uses real foreign keys for both of the columns, uses a
+  composite primary key of both of the columns, and adds an
+  additional composite index of the columns in reverse order.  The
+  primary key and additional index should ensure that almost all
+  operations on the join table can benefit from an index.
+
+  In terms of customization, the values in the hash can be hashes
+  themselves for column specific options, and an additional options
+  hash can also be given to override some of the default settings.
+
+  Database#drop_join_table also exists and takes the same options
+  as create_join_table.  It mostly exists to make it easy to
+  reverse migrations that use create_join_table.
+
+* Model#freeze has been added that freezes a model such that it
+  works correctly in a read-only state.  Before, it used the standard
+  Object#freeze, which broke some things that should work, and
+  allowed changes that shouldn't be allowed (like modifying the
+  instance's values).
+
+* ConnectionPool#all_connections has been added, which yields each
+  available connection in the pool to the block.  For threaded pools,
+  it does not yield connections that are currently being used by
+  other threads.  When using this method, it is important to only
+  operate on the yielded connection objects, and not make any
+  modifications to the pool itself.  The pool is also locked until
+  the method returns.
+
+* ConnectionPool#after_connect= has been added, allowing you to
+  change a connection pool's after_connect proc after instantiating
+  the pool.
+
+* ConnectionPool#disconnection_proc= has been added, allowing you to
+  change a connection pool's disconnection_proc after instantiating the
+  pool.
+
+* A Model.cache_anonymous_models accessor has been added, and can be
+  set to false to disable the caching of classes created by
+  Sequel::Model().  This caching is only useful if you want to reload
+  the model's file without getting a superclass mismatch.  This
+  setting is true by default for backwards compatibility, but may be
+  changed to false in a later version, so you should manually set it to
+  true if you are using code reloading.
+
+* Model.instance_dataset has been added for getting the dataset used
+  for model instances (a naked dataset restricted to a single row).
+
+* Dataset#with_sql_delete has been added for running the given SQL
+  string as a delete and returning the number of rows modified.  It's
+  designed as a replacement for with_sql(sql).delete, which is slower
+  as it requires cloning the dataset.
+
+* The :on_update and :on_delete entries for foreign_key now accept
+  string arguments which are used literally.
+
+* Prepared statement objects now have a log_sql accessor that can be
+  turned on to log the entire SQL statement instead of just the
+  prepared statement name.
+
+* Dataset#multi_replace has been added on MySQL.  This is similar to
+  multi_insert, but uses REPLACE instead of INSERT.
+
+* Dataset#explain has been added to MySQL.  You can use an
+  :extended=>true option to use EXPLAIN EXTENDED.
+
+* A Database#type_supported? method has been added on PostgreSQL to
+  check if the database supports the given type:
+
+    DB.type_supported?(:hstore)
+
+* Datatabase#reset_conversion_procs has been added to the postgres
+  adapter, for use by extensions that modify the default conversion
+  procs and want to have the database use the updated defaults.
+
+* A Database#convert_infinite_timestamps accessor has been added to
+  the postgres adapter, allowing you to return infinite timestamps as
+  nil, a string, or a float.
+
+* SQL::PlaceholderLiteralString objects can now use a placeholder
+  array, where placeholder values are inserted between array elements.
+  This is about 2.5-3x faster than using a string with ? placeholders,
+  and allows usage of ? inside the array:
+
+    Sequel.lit(["(", " ? ", ")"], 1, 2)  # (1 ? 2)
+
+* SQL::Subscript#[] has been added for accessing members of a
+  multi-dimensional array:
+
+    Sequel.subscript(:column, 1)[2][3]  # column[1][2][3] 
+
+* SQL::Wrapper has been added for wrapping arbitrary objects in a
+  Sequel expression object.
+
+* SQL::QualifiedIdentifier objects can now contain arbitrary Sequel
+  expressions.  Before, they could only contain a few expression
+  types.  This makes it easier to add extensions to support
+  PostgreSQL row-valued types.
+
+= Performance Improvements
+
+* Model.[] when called with a primary key has been made about 110%
+  faster for most models by avoiding cloning datasets.
+
+* Model.[] when called without arguments or with a single nil argument
+  is much faster as it now returns nil immediately instead of issuing
+  a database query.
+
+* Model#delete and Model#destroy have been made about 75% faster for
+  most models by using a static SQL string.
+
+* Model.new is now twice as fast when passed an empty hash.
+
+* Model#set is now four times as fast when passed an empty hash.
+
+* Model#this has been made about 85% faster by reducing the number of
+  dataset clones needed from 3 to 1.
+
+* Some proc activations have been removed, giving minor speedups when
+  running on MRI.
+
+= Other Improvements
+
+* Database#uri and #url now return the connection string given
+  to Sequel.connect.  Previously, they tried to reconstruct the
+  url using the database's options, but that didn't work well in
+  corner cases.
+
+* Database#inspect now shows the URL and/or options given when
+  connecting to the database.  Previously, it showed the URL, or
+  all of the databases options if constructing the URL raised an
+  error.
+
+* Sequel no longer checks for prepared transactions support when
+  using transactions unless a prepared transaction is specifically
+  requested.
+
+* The schema utility dataset cached in the Database object is now
+  reset if you use Database#extend_datasets, ensuring that the new
+  value will use the given extension.
+
+* The prepared_statements* plugins now log the full SQL by default.
+  Since the user doesn't choose the name of the prepared statements,
+  it was often difficult to determine what SQL was actually run if
+  you were only looking at a subsection of the SQL log.
+
+* The nested_attributes plugin's delete/remove support now works
+  correctly when a false value is given for _delete/_remove and
+  strict_param_setting is true.
+
+* The hook_class_methods and validation_class_methods plugins
+  now work correctly when subclassing if the subclass attempts to
+  create instances inside Model.inherited.
+
+* The caching plugin has been refactored.  Model.cache_get_pk and
+  cache_delete_pk have been added for retrieving/deleting from the
+  cache by primary key.  Model.cache_key is now a public method.
+
+* The typecast_on_load plugin now works correctly when saving
+  new model objects when insert_select is supported.
+
+* In the sql_expr extension, nil.sql_expr is no longer treated as
+  a boolean value.  It is now treated as a value with generic type.
+
+* The postgres adapter no longer issues a query to map type names to
+  type oids if no named conversion procs have been registered.
+
+* The postgres adapter now works around issues in ruby-pg by
+  supporting fractional seconds for Time/DateTime values, and
+  supporting SQL::Blob (bytea) values with embedded "\0" characters.
+
+* The postgres adapter now supports pre-defining the PG_NAMED_TYPES
+  and PG_TYPES constants.  This is so extensions can define them,
+  so they don't have to load the postgres adapter file first. If
+  extensions need to use these constants, they should do:
+
+    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
+    PG_TYPES = {} unless defined?(PG_TYPES)
+
+  That way they work whether they are loaded before or after the
+  postgres adapter.
+
+* PostgreSQL 8.2-9.0 now correctly add the RETURNING clause when
+  building queries.  Sequel 3.31.0 added support for returning values
+  from delete/update queries in PostgreSQL 8.2-9.0, but didn't change
+  the literalization code to use the RETURNING clause on those
+  versions.
+
+* The jdbc/postgres adapter now converts Java arrays
+  (Java::OrgPostgresqlJdbc4::Jdbc4Array) to ruby arrays.
+
+* Tables and schemas with embedded ' characters are now handled
+  correctly when parsing primary keys and sequences on PostgreSQL.
+
+* Identifiers are now escaped on MySQL and SQLite. Previously they
+  were quoted, but internal ` characters were not doubled.
+
+* Fractional seconds for the time type are now returned correctly on
+  jdbc (assuming they are returned as java.sql.Time values by JDBC).
+
+* Multiple changes were made to ensure that Sequel works correctly
+  when the core extensions are not loaded.
+
+* Composite foreign key constraints are now retained when emulating
+  alter_table operations on SQLite.  Previously, only single
+  foreign key constraints were retained.
+
+* An error is no longer raised when no indexes exist when calling
+  Database#indexes on jdbc/sqlite.
+
+* A possible SystemStackError has been fixed in the SQLite adapter,
+  when trying to delete a dataset that uses a having clause and no
+  where clause.
+
+* ROLLUP/CUBE support now works correctly on Microsoft SQL Server
+  2005.
+
+* Unsigned tinyint types are now recognized in the schema dumper.
+
+* Using primary_key :column, :type=>Bignum now works correctly on H2.
+  Previously, the column created was not autoincrementing.
+
+* Using a bound variable for a limit is now supported in the ibmdb
+  adapter on ruby 1.9.
+
+* Connecting to PostgreSQL via the swift adapter has been fixed when
+  using newer versions of swift. 
+
+* The mock adapter now handles calling the Database#execute methods
+  directly (instead of via a dataset).
+
+* The mock adapter now has the ability to have per-shared adapter
+  specific initialization code executed.  This has been used to fix
+  some bugs when using the shared postgres adapter.
+
+* The pretty_table extension has been split into two extensions, one
+  that adds a method to Dataset and one that just adds the
+  PrettyTable class.  Also, PrettyTable.string has been added to get
+  a string copy of the table.
+
+* A spec_model_no_assoc task has been added for running model specs
+  without the association plugin loaded.  This is to check that the
+  SEQUEL_NO_ASSOCIATIONS setting works correctly.
+
+= Deprecated Features to be Removed in Sequel 3.35.0
+
+* Ruby <1.8.7 support is now deprecated.
+
+* PostgreSQL <8.2 support is now deprecated.
+
+* Dataset#disable_insert_returning on PostgreSQL is now deprecated.
+  Starting in 3.35.0, RETURNING will now always be used to get the
+  primary key value when inserting.
+
+* Array#all_two_pairs? is now deprecated.  It was part of the core
+  extensions, but the core extensions have been refactored to no
+  longer require it.  As it doesn't specifically relate to creating
+  Sequel expression objects, it is being removed.  The private
+  Array#sql_expr_if_all_two_pairs method is deprecated as well.
+
+= Other Backwards Compatibility Issues
+
+* The generic Bignum type now uses bigint on SQLite, similar to
+  other databases.  The integer type was previously used.  The only
+  exception is for auto incrementing primary keys, which still use
+  integer for Bignum as SQLite doesn't support autoincrementing
+  columns other than integer.
+
+* On SQLite, Dataset#explain now returns a string, similar to
+  PostgreSQL (and now MySQL).
+
+* When using the JDBC adapter, Java::OrgPostgresqlUtil::PGobject
+  objects are converted to ruby strings if the dataset is set to
+  convert types (the default setting).  This is to support the
+  hstore extension, but it could have unforeseen effects if custom
+  types were used.
+
+* For PostgreSQL connection objects, #primary_key and #sequence now
+  require their arguments are provided as already literalized
+  strings.  Note that these methods are being removed in the next
+  version because they will not be needed after PostgreSQL <8.2
+  support is dropped.
+
+* Database#uri and #url now return a string or nil, but never raise
+  an exception.  Previously, they would either return a string
+  or raise an exception.
+
+* The Model @simple_pk and @simple_table instance variables should
+  no longer be modified directly.  Instead, the setter methods should
+  be used.
+
+* Model.primary_key_lookup should no longer be called with a nil
+  value.
+
+* Logging of prepared statements on some adapters has been changed
+  slightly, so log parsers might need to be updated.
+
+* Dataset#identifier_append and #table_ref_append no longer treat
+  literal strings and blobs specially.  Previously, they were treated
+  as identifiers.
+
+* Dataset#qualified_identifier_sql_append now takes 3 arguments, so
+  any extensions that override it should be modified accordingly.
+
+* Some internally used constants and private methods have been
+  deleted:
+
+    Database::CASCADE
+    Database::NO_ACTION
+    Database::SET_DEFAULTS
+    Database::SET_NULL
+    Database::RESTRICT
+    Dataset::COLUMN_ALL
+
+  or moved:
+
+    MySQL::Dataset::AFFECTED_ROWS_RE -> MySQL::Database
+    MySQL::Dataset#affected_rows -> MySQL::Database
+
+* The sql_expr extension no longer creates the
+  Sequel::SQL::GenericComplexExpression class.