sequel 3.1.0 → 3.2.0

data/CHANGELOG

@@ -1,3 +1,79 @@
+=== 3.2.0 (2009-07-02)
+
+* In the STI plugin, don't overwrite the STI field if it is already set (jeremyevans)
+
+* Add support for Common Table Expressions, which use the SQL WITH clause (jeremyevans)
+
+* Add SQL::WindowFunction, expand virtual row blocks to support them and other constructions (jeremyevans)
+
+* Add Model#autoincrementing_primary_key, for when the autoincrementing key isn't the same as the primary key (jeremyevans)
+
+* Add Dataset#ungraphed, to remove the splitting of results into subhashes or associated records (jeremyevans)
+ 
+* Support :opclass option for PostgreSQL indexes (tmi, jeremyevans)
+
+* Make parsing of server's version more reliable for PostgreSQL (jeremyevans)
+
+* Add Dataset#qualify, which is qualify_to with a first_source default (jeremyevans)
+
+* Add :ruby_default to parsed schema information, which contains a ruby object representing the database default (jeremyevans)
+
+* Fix changing a column's name, type, or null status on MySQL when column has a string default (jeremyevans)
+
+* Remove Dataset#to_table_reference protected method, no longer used (jeremyevans)
+
+* Fix thread-safety issue in stored procedure code (jeremyevans)
+
+* Remove SavepointTransactions module, integrate into Database code (jeremyevans)
+
+* Add supports_distinct_on? method (jeremyevans)
+
+* Remove SQLStandardDateFormat, replace with requires_sql_standard_datetimes? method (jeremyevans)
+
+* Remove UnsupportedIsTrue module, replace with supports_is_true? method (jeremyevans)
+
+* Remove UnsupportedIntersectExcept(All)? modules, replace with methods (jeremyevans)
+
+* Make Database#indexes work on PostgreSQL versions prior to 8.3 (tested on 7.4) (jeremyevans)
+
+* Fix bin/sequel using a YAML file on 1.9 (jeremyevans)
+
+* Allow connection pool options to be specified in connection string (jeremyevans)
+
+* Handle :user and :password options in the JDBC adapter (jeremyevans)
+
+* Fix warnings when using the ODBC adapter (jeremyevans)
+
+* Add opening_databases.rdoc file for describing how to connect to a database (mwlang, jeremyevans)
+
+* Significantly increase JDBC select performance (jeremyevans)
+
+* Slightly increase SQLite select performance using the native adapter (jeremyevans)
+
+* Majorly increase MySQL select performance using the native adapter (jeremyevans)
+
+* Pass through unsigned/elements/size and other options when altering columns on MySQL (tmm1)
+
+* Allow on_duplicate_key_update to affect Dataset#insert on MySQL (tmm1)
+
+* Support using a given table and column to store schema versions, using new Migrator.run method (bougyman, jeremyevans)
+
+* Fix foreign key table constraints on MySQL (jeremyevans)
+
+* Remove Dataset#table_exists?, use Database#table_exists? instead (jeremyevans)
+
+* Fix graphing of datasets with dataset sources (jeremyevans) (#271)
+
+* Raise a Sequel::Error if Sequel.connect is called with something other than a Hash or String (jeremyevans) (#272)
+
+* Add -N option to bin/sequel to not test the database connection (jeremyevans)
+
+* Make Model.grep call Dataset#grep instead of Enumerable#grep (jeremyevans)
+
+* Support the use of Regexp as first argument to StringExpression.like (jeremyevans)
+
+* Fix Database#indexes on PostgreSQL when the schema used is a symbol (jeremyevans)
+
 === 3.1.0 (2009-06-04)
 
 * Require the classes match to consider an association a reciprocal (jeremyevans) (#270)

data/Rakefile

@@ -164,14 +164,14 @@ begin
   
   desc "Run integration tests"
   Spec::Rake::SpecTask.new("integration") do |t|
-    t.spec_files = FileList["spec/integration/*_test.rb"]
+    t.spec_files = Dir["spec/integration/*_test.rb"]
     t.spec_opts  = spec_opts.call
   end
   
   %w'postgres sqlite mysql informix oracle ado'.each do |adapter|
     desc "Run #{adapter} specs without coverage"
     Spec::Rake::SpecTask.new("spec_#{adapter}") do |t|
-      t.spec_files = ["spec/adapters/#{adapter}_spec.rb"]
+      t.spec_files = ["spec/adapters/#{adapter}_spec.rb"] + Dir["spec/integration/*_test.rb"]
       t.spec_opts  = spec_opts.call
     end
   end

data/bin/sequel

@@ -13,6 +13,7 @@ logfile = nil
 migrate_dir = nil
 migrate_ver = nil
 backtrace = nil
+test_connection = true
 load_dirs = []
 
 opts = OptionParser.new do |opts|
@@ -69,6 +70,10 @@ opts = OptionParser.new do |opts|
     migrate_ver = Integer(v)
   end
 
+  opts.on("-N", "--no-test-connection", "do not test the connection") do
+    test_connection = false
+  end
+
   opts.on("-t", "--trace", "Output the full backtrace if an exception is raised") do
     backtrace = true
   end
@@ -100,21 +105,22 @@ if logfile || echo
 end
 
 connect_proc = lambda do |database|
-  if File.exist?(database)
+  db = if 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.each{|(k,v)| db_config[k.to_sym] = db_config.delete(k)}
+    db_config.keys.each{|k| db_config[k.to_sym] = db_config.delete(k)}
     Sequel.connect(db_config.merge!(db_opts))
   else
     Sequel.connect(database, db_opts)
   end
+  db.test_connection if test_connection
+  db
 end
 
 begin
   DB = connect_proc[db]
-  DB.test_connection
   if migrate_dir
     Sequel.extension :migration
     Sequel::Migrator.apply(DB, migrate_dir, migrate_ver)
@@ -132,7 +138,6 @@ begin
     error_proc["Error: Must specify database connection string or path to yaml file as second argument for database you want to copy to"] if db2.nil? || db2.empty?
     start_time = Time.now
     TO_DB = connect_proc[db2]
-    TO_DB.test_connection
     same_db = DB.database_type==TO_DB.database_type
 
     puts "Databases connections successful"

data/doc/opening_databases.rdoc

@@ -0,0 +1,279 @@
+= Connecting to a database
+
+All Sequel activity begins with connecting to a database, which creates a
+Sequel::Database object. The Database object is used to create datasets and execute
+queries. Sequel provides a powerful and flexible mechanism for connecting to
+databases.  There are two main ways to establish database connections:
+
+1. Using the Sequel.connect method
+2. Using the specialized adapter method (Sequel.sqlite, Sequel.postgres, etc.)
+
+The connection options needed depend on the adapter being used, though most adapters
+share the same basic connection options.
+
+If you are only connecting to a single database, it is recommended that you store the
+database object in a constant named DB.  This should never be required, but it is the
+convention that most Sequel code uses.
+
+== Using the Sequel.connect method
+
+The connect method usually takes a well-formed URI, which is parsed into connection options needed to open
+the database connection.  The scheme/protocol part of the URI is used to determine the adapter to use:
+
+  DB = Sequel.connect('postgres://user:password@localhost/blog') # Uses the postgres adapter
+
+You can use URI query parameters to specify options:
+
+  DB = Sequel.connect('postgres://localhost/blog?user=user&password=password')
+
+You can also pass an additional option hash with the connection string:
+
+  DB = Sequel.connect('postgres://localhost/blog' :user=>'user', :password=>'password')
+
+You can also just use an options hash without a connection string.  If you do this, you must
+provide the adapter to use:
+
+  DB = Sequel.connect(:adapter=>'postgres', :host=>'localhost', :database=>'blog', :user=>'user', :password=>'password')
+
+All of the above statements are equivalent.
+
+== Using the specialized adapter method
+
+The specialized adapter method is similar to Sequel.connect with an options hash, except that it
+automatically populates the :adapter option and assumes the first argument is the :database option,
+unless the first argument is a hash. So the following statements are equivalent to the previous statements.
+
+  DB = Sequel.postgres('blog', :host=>'localhost', :user=>'user', :password=>'password')
+  DB = Sequel.postgres(:host=>'localhost', :user=>'user', :password=>'password', :database=>'blog')
+
+== Passing a block to either method
+
+Both the Sequel.connect method and the specialized adapter methods take a block.  If you
+provide a block to the method, Sequel will open the connection and pass it as an argument
+to the block.  When the block is exited, Sequel will disconnect the database connection.
+For example:
+
+  Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
+
+== General connection options
+
+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 the single-threaded (non-thread safe) connection pool
+* :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.
+
+* :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
+
+The following sections explain the options and behavior specific to each adapter.
+If the library the adapter requires is different from the name of the adapter
+scheme, it is listed specifically, otherwise you can assume that is requires the
+library with the same name.
+
+=== ado
+
+Requires: win32ole 
+
+The ADO adapter provides connectivity to ADO databases in Windows. It relies
+on WIN32OLE library, so it isn't usable on other operating systems (except
+possibly through WINE, but that's fairly unlikely).
+
+The following options are supported:
+* :driver - The driver to use.  The default if not specified is 'SQL Server'.
+* :command_timeout - Sets the time in seconds to wait while attempting
+    to execute a command before cancelling the attempt and generating
+    an error. Specifically, it sets the ADO CommandTimeout property.
+    If this property is not set, the default of 30 seconds is used.
+* :provider - Sets the Provider of this ADO connection (for example, "SQLOLEDB")
+
+=== amalgalite 
+
+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
+
+Without a database argument, assumes a memory database, so you can do:
+
+  Sequel.amalgalite
+
+Handles paths in the connection string similar to the SQLite adapter, so see
+the sqlite section below for details.
+
+=== db2 
+
+Requires: db2/db2cli
+
+I'm not even sure exactly how this works, or if it works at all (I've never heard from
+anyone who attempted to use it).  It uses the SQL_HANDLE_DBC constant to
+get a handle, and respects the :database, :user, and :password options.  It doesn't
+appear to respect the :host or :port options.
+
+=== dbi 
+
+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.
+
+DBI connection strings are a preprocessed a bit, and are specified with a dbi-
+in front of the protocol.  Examples:
+
+  dbi-ado://...
+  dbi-db2://...
+  dbi-frontbase://...
+  dbi-interbase://...
+  dbi-msql://...
+  dbi-mysql://...
+  dbi-odbc://...
+  dbi-oracle://...
+  dbi-pg://...
+  dbi-proxy://...
+  dbi-sqlite://...
+  dbi-sqlrelay://...
+
+While the DBI adapter does work, it is recommended that you use another adapter
+if your database supports it.
+
+=== do 
+
+Requires: data_objects
+
+The DataObjects adapter supports PostgreSQL, MySQL, and SQLite.  One possible
+advantage of using DataObjects is that it does the typecasting in C, which may
+be faster than the other adapters.
+
+Similar to the JDBC adapter, the DO adapter only cares about connection strings,
+which can either be the String argument given to Sequel.connect directly or contained
+in a :uri or :url option.  The DO adapter passes through the connection string
+directly to DataObjects, it does no processing of it.
+
+Connection string examples:
+
+  do:sqlite3::memory:
+  do:postgres://user:password@host/database
+  do:mysql://user:password@host/database
+
+=== firebird 
+
+Requires: fb (using code at http://github.com/wishdev/fb)
+
+Does not support the :port option.
+
+=== informix 
+
+Does not support the :host or :port options.
+
+=== jdbc 
+
+Requires: java
+
+Houses Sequel's JDBC support when running on JRuby.
+Support for individual database types is done using sub adapters.
+There are currently subadapters for PostgreSQL, MySQL, SQLite, H2,
+Oracle, and MSSQL.  All except Oracle and MSSQL can load the
+JDBC gem, for those you need to have the .jar in your CLASSPATH
+or load the Java class manually.
+
+You just use the JDBC connection string directly, which can be specified
+via the string given to Sequel.connect or via the :uri, :url, or :database options.
+Sequel does no preprocessing of the string, it passes it directly to JDBC.
+So if you have problems getting a connection string to work, look up the JDBC
+documentation.
+
+Example connections strings:
+
+  jdbc:sqlite::memory:
+  jdbc:postgresql://localhost/database?user=username
+  jdbc:mysql://localhost/test?user=root&password=root
+  jdbc:h2:mem:
+
+=== mysql 
+
+The MySQL adapter does not support the pure-ruby MySQL adapter that ships with
+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.
+* :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.
+
+=== odbc 
+
+The ODBC adapter allows you to connect to any database with the appropriate ODBC drivers installed.  
+The :database option given ODBC database should be the DSN (Descriptive Service Name) from the ODBC configuration.
+
+  Sequel.odbc('mydb', :user => "user", :password => "password")
+
+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.
+
+=== openbase 
+
+The :port option is ignored.
+
+=== oracle 
+
+Requires: oci8
+
+The following additional options are supported:
+
+* :privilege - The Oracle privilege level.
+
+=== postgres
+
+Requires: pg (or postgres if pg is not available)
+
+The Sequel postgres adapter works with the pg, postgres, and postgres-pr ruby libraries.
+The pg library is the best supported, as it supports real bound variables and prepared statements.
+
+The following additional options are supported:
+
+* :charset - Same as :encoding, :encoding takes precedence
+* :encoding - Set the client_encoding to the given string
+
+=== sqlite
+
+As SQLite is a file-based database, the :host and :port options are ignored, and
+the :database option should be a path to the file.
+
+Examples:
+
+  # In Memory databases:
+  Sequel.sqlite
+  Sequel.connect('sqlite:/') 
+  Sequel.sqlite(':memory:')
+
+  # Relative Path
+  Sequel.sqlite('blog.db')
+  Sequel.sqlite('./blog.db')
+  Sequel.connect('sqlite://blog.db')
+
+  # Absolute Path
+  Sequel.sqlite('/var/sqlite/blog.db')
+  Sequel.connect('sqlite:///var/sqlite/blog.db') 
+
+The following additional options are supported:
+
+* :timeout - the busy timeout to use in milliseconds (default: 5000).

data/doc/release_notes/3.2.0.txt

@@ -0,0 +1,268 @@
+New Features
+------------
+
+* Common table expressions (CTEs) are now supported.  CTEs use the
+  SQL WITH clause, and specify inline views that queries can use.
+  They also support a recursive mode, where the CTE can recursively
+  query its own output, allowing you do do things like load all
+  branches for a given node in a plain tree structure.
+  
+  The standard with takes an alias and a dataset:
+  
+    DB[:vw].with(:vw, DB[:table].filter{col < 1})
+    # WITH vw AS (SELECT * FROM table WHERE col < 1)
+    # SELECT * FROM vw
+    
+  The recursive with takes an alias, a nonrecursive dataset, and a
+  recursive dataset:
+    
+    DB[:vw].with_recursive(:vw,
+      DB[:tree].filter(:id=>1),
+      DB[:tree].join(:vw, :id=>:parent_id).
+                select(:vw__id, :vw__parent_id))
+    # WITH RECURSIVE vw AS (SELECT * FROM tree
+    #     WHERE (id = 1)
+    #     UNION ALL
+    #     SELECT vw.id, vw.parent_id
+    #     FROM tree
+    #     INNER JOIN vw ON (vw.id = tree.parent_id))
+    # SELECT * FROM vw
+
+  CTEs are supported by Microsoft SQL Server 2005+, DB2 7+,
+  Firebird 2.1+, Oracle 9+, and PostgreSQL 8.4+.
+  
+* SQL window functions are now supported, and a DSL has been added to
+  ease their creation.  Window functions act similarly to aggregate
+  functions but operate on sliding ranges of rows.
+  
+  In virtual row blocks (blocks passed to filter, select, order, etc.)
+  you can now provide a block to method calls to change the default
+  behavior to create functions that weren't possible previously.  The
+  blocks aren't called, but their presence serves as a flag.
+  
+  What function is created depends on the arguments to the method:
+  
+  * If there are no arguments, an SQL::Function is created with the
+    name of method used, and no arguments.  Previously, it was not
+    possible to create functions without arguments using the virtual
+    row block DSL.  Example:
+    
+      DB.dataset.select{version{}} # SELECT version()
+    
+  * If the first argument is :*, an SQL::Function is created with a
+    single wildcard argument (*).  This is mostly useful for count:
+    
+      DB[:t].select{count(:*){}} # SELECT count(*) FROM t
+    
+  * If the first argument is :distinct, an SQL::Function is created
+    with the keyword DISTINCT prefacing all remaining arguments. This
+    is useful for aggregate functions such as count:
+    
+      DB[:t].select{count(:distinct, col1){}}
+      # SELECT count(DISTINCT col1) FROM t
+    
+  * If the first argument is :over, the second argument, if provided,
+    should be a hash of options to pass to SQL::Window.  The options
+    hash can also contain :*=>true to use a wildcard argument as the
+    function argument, or :args=>... to specify an array of arguments
+    to use as the function arguments.
+
+      DB[:t].select{rank(:over){}} # SELECT rank() OVER ()
+      DB[:t].select{count(:over, :*=>true){}} # SELECT count(*) OVER ()
+      DB[:t].select{sum(:over, :args=>col1,
+                    :partition=>col2, :order=>col3){}}
+      # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3)
+      
+  PostgreSQL also supports named windows.  Named windows can be
+  specified by Dataset#window, and window functions can reference
+  them using the :window option.
+  
+* Schema information for columns now includes a :ruby_default entry
+  which contains a ruby object that represents the default given by
+  the database (which is stored in :default).  Not all :default
+  entries can be parsed into a :ruby_default, but if the
+  schema_dumper extension previously supported it, it should work.
+
+* Methods to create compound datasets (union, intersect, except), now
+  take an options hash instead of a true/false flag.  The previous
+  API is still supported, but switching to specifying the ALL setting
+  using :all=>true is recommended.
+  
+  Additionally, you can now set :from_self=>false to not wrap the
+  returned dataset in a "SELECT * FROM (...)".
+  
+* Dataset#ungraphed was added that removes the graphing information
+  from the dataset.  This allows you to use Dataset#graph for the
+  automatic aliasing, or #eager_graph for the automatic aliasing and
+  joining, and then remove the graphing information so that the
+  resulting objects will not be split into subhashes or associations.
+
+* There were some introspection methods added to Dataset to describe
+  which capabilities that dataset does or does not support:
+  
+    supports_cte?
+    supports_distinct_on?
+    supports_intersect_except?
+    supports_intersect_except_all?
+    supports_window_functions?
+
+  In addition to being available for the user to use, these are also
+  used internally, so attempting to use a CTE on a dataset that
+  doesn't support it will raise an Error.
+
+* Dataset#qualify was added, which is like qualify_to with a default
+  of first_source.
+
+  Additionally, qualify now affects PlaceholderLiteralStrings.  It
+  doesn't scan the string (as Sequel never attempts to parse SQL),
+  but if you provide the column as a symbol placeholder argument, it
+  will qualify it.
+  
+* You can now specify the table and column Sequel::Migrator will use
+  to record the current schema version.  The new Migrator.run method
+  must be used to use these new options.
+  
+* The JDBC adapter now accepts :user and :password options, instead
+  of requiring them to be specified in the connection string and 
+  handled by the JDBC driver.  This should allow connections to
+  Oracle using the Thin JDBC driver.
+  
+* You can now specify the max_connections, pool_timeout, and
+  single_threaded settings directly in the connection string:
+  
+    postgres:///database?single_threaded=t
+    postgres:///database?max_connections=10&pool_timeout=20
+
+* Dataset#on_duplicate_key_update now affects Dataset#insert when
+  using MySQL.
+
+* You can now specify the :opclass option when creating PostgreSQL
+  indexes.  Currently, this only supports a single operator class
+  for all columns.  If you need different operator classes per
+  column, please post on sequel-talk.
+  
+* Model#autoincrementing_primary_key was added and can be used if
+  the autoincrementing key isn't the same as the primary key.  The
+  only likely use for this is on MySQL MyISAM tables with composite
+  primary keys where only one of the composite parts is
+  autoincrementing.
+
+* You can now use database column values as search patterns and
+  specify the text to search as a String or Regexp:
+  
+    String.send(:include, Sequel::SQL::StringMethods)
+    Regexp.send(:include, Sequel::SQL::StringMethods)
+
+    'a'.like(:x)  # ('a' LIKE x)
+    /a/.like(:x)  # ('a' ~ x)
+    /a/i.like(:x) # ('a' ~* x)
+    /a/.like(:x, 'b') # (('a' ~ x) OR ('a' ~ 'b'))
+
+* The Dataset#dataset_alias private method was added.  It can be
+  overridden if you have tables named t0, t1, etc and want to make
+  sure the default dataset aliases that Sequel uses do not clash
+  with existing table names.
+  
+* Sequel now raises an Error if you call Sequel.connect with
+  something that is not a Hash or String.
+  
+* bin/sequel now accepts a -N option to not test the database
+  connection.
+  
+* An opening_databases.rdoc file was added to the documentation
+  directory, which should be a good introduction for new users about
+  how to set up your Database connection.
+
+Other Improvements
+------------------
+
+* MySQL native adapter SELECT is much faster than before, up to 75%
+  faster.
+
+* JDBC SELECT is about 10% faster than before.  It's still much
+  slower than the native adapters, due to conversion issues.
+
+* bin/sequel now works with a YAML file on ruby 1.9.
+
+* MySQL foreign key table constraints have been fixed.
+
+* Database#indexes now works on PostgreSQL if the schema used is a
+  Symbol.  It also works on PostgreSQL versions all the way back to
+  7.4.
+
+* Graphing of datasets with dataset sources has been fixed.
+
+* Changing a columns name, type, or NULL status on MySQL now
+  supports a much wider selection of column defaults.
+  
+* The stored procedure code is now thread-safe.  Sequel is
+  thread-safe in general, but due to a bug the previous stored 
+  procedure code was not thread-safe.
+
+* The ODBC adapter now drops statements automatically instead of
+  requiring the user to do so manually, making it more similar
+  to other adapters.
+
+* The single_table_inheritance plugin no longer overwrites the STI
+  field if the field already has a value.  This allows you to use
+  create in the generic class to insert a value that will be
+  returned as a subclass:
+  
+    Person.create(:kind => "Manager")
+    
+* When altering colums on MySQL, :unsigned, :elements, :size and other
+  options given are no longer ignored.
+
+* The PostgreSQL shared adapter's explain and analyze methods have
+  been fixed, they had been broken in 3.0.
+  
+* Parsing of the server's version is more robust on PostgreSQL.
+  It should now work correctly for 8.4 and 8.4rc1 type versions.
+
+Backwards Compatibility
+-----------------------
+
+* Dataset#table_exists? has been removed, since it never worked
+  perfectly.  Use Database#table_exists? instead.
+  
+* Model.grep now calls Dataset#grep instead of Enumerable#grep.
+  If you are using Model.grep, you need to modify your application.
+
+* The MSSQL shared adapter previously used the :with option for
+  storing the NOLOCK setting of the query.  That option has been
+  renamed to :table_options, since :with is now used for CTEs.
+  This should not have an effect unless you where using the option
+  manually.
+
+* Previously, providing a block to a method calls in virtual row
+  blocks did not change behavior, where now it causes a different
+  code path to be used.  In both cases, the block is not evaluated,
+  but that may change in a future version.
+  
+* Dataset#to_table_reference protected method was removed, as it was
+  no longer used.
+  
+* The pool_timeout setting is now converted to an Integer, so if you
+  used to pass in a Float, it no longer works the same way.
+  
+* Most files in adapters/utils have been removed, in favor of 
+  integrating the code directly into Database and Dataset.  If you
+  were previously checking for the UnsupportedIntersectExcept or
+  related modules, use the Dataset introspection methods instead
+  (e.g. supports_intersect_except?).
+  
+* If you were using the ODBC adapter and manually dropping returned
+  statements, you should note that now statements are dropped
+  automatically, and the execute method doesn't return a statement
+  object.
+  
+* The MySQL adapter on_duplicate_key_update_sql is now a private
+  method.
+  
+* If you were modifying the :from dataset option directly, note that
+  Sequel now expects this option to be preprocessed.  See the new
+  implementation of Dataset#from for an idea of the changes
+  required.
+  
+* Dataset#simple_select_all? now returns false instead of true for a
+  dataset that selects from another dataset.