sequel 3.0.0 → 3.1.0

data/CHANGELOG

@@ -1,3 +1,103 @@
+=== 3.1.0 (2009-06-04)
+
+* Require the classes match to consider an association a reciprocal (jeremyevans) (#270)
+
+* Make Migrator work correctly with file names like 001_873465873465873465_some_name.rb (jeremyevans) (#267)
+
+* Add Dataset#qualify_to and #qualify_to_first_source, for qualifying unqualified identifiers in the dataset (jeremyevans)
+
+* All the use of #sql_subscript on most SQL::* objects, and support non-integer subscript values (jeremyevans)
+
+* Add reflection.rdoc file which explains and gives examples of many of Sequel's reflection methods (jeremyevans)
+
+* Add many_through_many plugin, allowing you to construct an association to multiple objects through multiple join tables (jeremyevans)
+
+* Add the :cartesian_product_number option to associations, for specifying if they can cause a cartesian product (jeremyevans)
+
+* Make :eager_graph association option work correctly when lazily loading many_to_many associations (jeremyevans)
+
+* Make eager_unique_table_alias consider joined tables as well as tables in the FROM clause (jeremyevans)
+
+* Make add_graph_aliases work correctly even if set_graph_aliases hasn't been used (jeremyevans)
+
+* Fix using :conditions that are a placeholder string in an association (e.g. :conditions=>['a = ?', 42]) (jeremyevans)
+
+* On MySQL, make Dataset#insert_ignore affect #insert as well as #multi_insert and #import (jeremyevans, tmm1)
+
+* Add -t option to bin/sequel to output the full backtrace if an exception is raised (jeremyevans)
+
+* Make schema_dumper extension ignore errors with indexes unless it is dumping in the database-specific type format (jeremyevans)
+
+* Don't dump partial indexes in the MySQL adapter (jeremyevans)
+
+* Add :ignore_index_errors option to Database#create_table and :ignore_errors option to Database#add_index (jeremyevans)
+
+* Make graphing a complex dataset work correctly (jeremyevans)
+
+* Fix MySQL command out of sync errors, disconnect from database if they occur (jeremyevans)
+
+* In the schema_dumper extension, do a much better job of parsing defaults from the database (jeremyevans)
+
+* On PostgreSQL, assume the public schema if one is not given and there is no default in Database#tables (jeremyevans)
+
+* Ignore a :default value if creating a String :text=>true or File column on MySQL, since it doesn't support defaults on text/blob columns (jeremyevans)
+
+* On PostgreSQL, do not raise an error when attempting to reset the primary key sequence for a table without a primary key (jeremyevans)
+
+* Allow plugins to have a configure method that is called on every attempt to load them (jeremyevans)
+
+* Attempting to load an already loaded plugin no longer calls the plugin's apply method (jeremyevans)
+
+* Make plugin's plugin_opts methods return an array of arguments if multiple arguments were given, instead of just the first argument (jeremyevans)
+
+* Keep track of loaded plugins at Model.plugins, allows plugins to depend on other plugins (jeremyevans)
+
+* Make Dataset#insert on PostgreSQL work with static SQL (jeremyevans)
+
+* Add lazy_attributes plugin, for creating attributes that can be lazily loaded from the database (jeremyevans)
+
+* Add tactical_eager_loading plugin, similar to DataMapper's strategic eager loading (jeremyevans)
+
+* Don't raise an error when loading a plugin with DatasetMethods where none of the methods are public (jeremyevans)
+
+* Add identity_map plugin, for creating temporary thread-local identity maps with some caching (jeremyevans)
+
+* Support savepoints when using MySQL and SQLite (jeremyevans)
+
+* Add -C option to bin/sequel that copies one database to another (jeremyevans)
+
+* In the schema_dumper extension, don't include defaults that contain literal strings unless the DBs are the same (jeremyevans)
+
+* Only include valid non-partial indexes of simple column references in the PostgreSQL adapter (jeremyevans)
+
+* Add -h option to bin/sequel for outputting the usage, alias for -? (jeremyevans)
+
+* Add -d and -D options to bin/sequel for dumping schema migrations (jeremyevans)
+
+* Support eager graphing for model tables that lack primary keys (jeremyevans)
+
+* Add Model.create_table? to the schema plugin, similar to Database#create_table? (jeremyevans)
+
+* Add Database#create_table?, which creates the table if it doesn't already exist (jeremyevans)
+
+* Handle ordered and limited datasets correctly when using UNION, INTERSECT, or EXCEPT (jeremyevans)
+
+* Fix unlikely threading bug with class level validations (jeremyevans)
+
+* Make the schema_dumper extension dump tables in alphabetical order in migrations (jeremyevans)
+
+* Add Sequel.extension method for loading extensions, so you don't have to use require (jeremyevans)
+
+* Allow bin/sequel to respect multiple -L options instead of ignoring all but the last one (jeremyevans)
+
+* Add :command_timeout and :provider options to ADO adapter (hgimenez)
+
+* Fix exception messages when Sequel.string_to_* fail (jeremyevans)
+
+* Fix String :type=>:text generic type in the Firebird adapter (wishdev)
+
+* Add Sequel.amalgalite adapter method (jeremyevans)
+
 === 3.0.0 (2009-05-04)
 
 * Remove dead threads from connection pool if the pool is full and a connection is requested (jeremyevans)

data/README.rdoc

@@ -44,15 +44,15 @@ If you have any comments or suggestions please post to the Google group.
   
   DB.create_table :items do
     primary_key :id
-    String name
-    Float price
+    String :name
+    Float :price
   end
   
   items = DB[:items] # Create a dataset
   
   # Populate the table
   items.insert(:name => 'abc', :price => rand * 100)
-  items.insert(name => 'def', :price => rand * 100)
+  items.insert(:name => 'def', :price => rand * 100)
   items.insert(:name => 'ghi', :price => rand * 100)
   
   # Print out the number of records

data/bin/sequel

@@ -5,12 +5,15 @@ require 'optparse'
 require 'sequel'
 
 db_opts = {}
+copy_databases = nil
+dump_migration = nil
 echo = nil
 env = nil
 logfile = nil
 migrate_dir = nil
 migrate_ver = nil
-load_dir = nil
+backtrace = nil
+load_dirs = []
 
 opts = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
@@ -25,11 +28,23 @@ opts = OptionParser.new do |opts|
   opts.separator ""
   opts.separator "Options:"
 
-  opts.on_tail("-?", "--help", "Show this message") do
+  opts.on_tail("-h", "-?", "--help", "Show this message") do
     puts opts
     exit
   end
 
+  opts.on("-C", "--copy-databases", "copy one database to another") do 
+    copy_databases = true
+  end
+  
+  opts.on("-d", "--dump-migration", "print database migration to STDOUT") do 
+    dump_migration = true
+  end
+  
+  opts.on("-D", "--dump-migration-same-db", "print database migration to STDOUT without type translation") do
+    dump_migration = :same_db
+  end
+
   opts.on("-e", "--env ENV", "use environment config for database") do |v|
     env = v
   end
@@ -42,8 +57,8 @@ opts = OptionParser.new do |opts|
     logfile = v
   end
   
-  opts.on("-L", "--load-dir DIR", "loads all *.rb from specifed directory") do |v|
-    load_dir = v
+  opts.on("-L", "--load-dir DIR", "loads all *.rb under specifed directory") do |v|
+    load_dirs << v
   end
   
   opts.on("-m", "--migrate-directory DIR", "run the migrations in directory") do |v|
@@ -54,6 +69,10 @@ opts = OptionParser.new do |opts|
     migrate_ver = Integer(v)
   end
 
+  opts.on("-t", "--trace", "Output the full backtrace if an exception is raised") do
+    backtrace = true
+  end
+  
   opts.on_tail("-v", "--version", "Show version") do
     puts "sequel #{Sequel.version}"
     exit
@@ -63,11 +82,16 @@ opts.parse!
 
 db = ARGV.shift
 
-if db.nil? || db.empty?
-  puts opts
+error_proc = lambda do |msg|
+  $stderr.puts(msg)
   exit 1
 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: Must specify database connection string or path to yaml file as argument"] if db.nil? || db.empty?
+
 if logfile || echo
   require 'logger'
   db_opts[:loggers] = []
@@ -75,30 +99,89 @@ if logfile || echo
   db_opts[:loggers] << Logger.new($stdout) if echo
 end
 
-if File.exist?(db)
-  require 'yaml'
-  env ||= "development"
-  db_config = YAML.load_file(db)
-  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.merge!(db_opts)
+connect_proc = lambda do |database|
+  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)}
+    Sequel.connect(db_config.merge!(db_opts))
+  else
+    Sequel.connect(database, db_opts)
+  end
 end
 
 begin
-  DB = Sequel.connect(*(db_config ? [db_config] : [db, db_opts]))
+  DB = connect_proc[db]
   DB.test_connection
   if migrate_dir
-    require 'sequel/extensions/migration'
+    Sequel.extension :migration
     Sequel::Migrator.apply(DB, migrate_dir, migrate_ver)
     exit
   end
+  if dump_migration
+    Sequel.extension :schema_dumper
+    puts DB.dump_schema_migration(:same_db=>dump_migration==:same_db)
+    exit
+  end
+  if copy_databases
+    Sequel.extension :migration, :schema_dumper
+
+    db2 = ARGV.shift
+    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"
+    schema_migration = eval(DB.dump_schema_migration(:indexes=>false, :same_db=>same_db))
+    index_migration = eval(DB.dump_indexes_migration(:same_db=>same_db))
+    puts "Migrations dumped successfully"
+
+    schema_migration.apply(TO_DB, :up)
+    puts "Tables created"
+
+    puts "Begin copying data"
+    DB.transaction do
+      TO_DB.transaction do
+        DB.tables.each do |table|
+          puts "Begin copying records for table: #{table}"
+          time = Time.now
+          to_ds = TO_DB.from(table)
+          j = 0
+          DB.from(table).each do |record|
+            if Time.now - time > 5
+              puts "Status: #{j} records copied" 
+              time = Time.now
+            end
+            to_ds.insert(record)
+            j += 1
+          end
+          puts "Finished copying #{j} records for table: #{table}"
+        end
+      end
+    end
+    puts "Finished copying data"
+
+    puts "Begin creating indexes"
+    index_migration.apply(TO_DB, :up)
+    puts "Finished creating indexes"
+
+    if TO_DB.database_type == :postgres
+      TO_DB.tables.each{|t| TO_DB.reset_primary_key_sequence(t)}
+      puts "Primary key sequences reset successfully"
+    end
+    puts "Database copy finished in #{Time.now - start_time} seconds"
+    exit
+  end
 rescue => e
-  puts "#{e.class}: #{e.message}"
-  puts e.backtrace.first
-  exit 1
+  raise e if backtrace
+  error_proc["Error: #{e.class}: #{e.message}#{e.backtrace.first}"]
 end
 
-Dir["#{load_dir}/**/*.rb"].each{|f| load(f)} if load_dir
+load_dirs.each{|d| Dir["#{d}/**/*.rb"].each{|f| load(f)}}
 
 require 'irb'
 puts "Your database is stored in DB..."

data/doc/reflection.rdoc

@@ -0,0 +1,83 @@
+= Reflection
+
+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:
+
+  DB.class.adapter_scheme # e.g. :postgres, :jdbc, :odbc
+
+== Database Connected To
+
+In some case, the adapter scheme will be the same as the database to which you are connecting.  However, many adapters support multiple databases.  You can use the Database#database_type method to get the type of database to which you are connecting:
+
+  DB.database_type # :postgres, :h2, :mssql
+
+== Tables in the Database
+
+On many database types/adapters, Database#tables exists and gives an array of table name symbols:
+
+  DB.tables # [:table1, :table2, :table3, ...]
+
+== Indexes on a table
+
+On a few database types/adapters, Database#indexes takes a table name gives a hash of index information.  Keys are index names, values are subhashes with the keys :columns and :unique :
+
+  DB.indexes(:table1) # {:index1=>{:columns=>[:column1], :unique=>false}, :index2=>{:columns=>[:column2, :column3], :unique=>true}}
+
+Index information generally does not include partial indexes, functional indexes, or indexes on the primary key of the table.
+
+== 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:
+
+* :allow_null - Whether NULL/nil is an allowed value for this column. Used by the Sequel::Model typecasting code.
+* :db_type - The type of column the database provided, as a string.  Used by the schema_dumper plugin for a more specific type translation.
+* :default - The default value of the column, as either a string or nil.  Uses a database specific format. Used by the schema_dumper plugin for converting to a ruby value.
+* :primary_key - Whether this column is one of the primary key columns for the table.  Used by the Sequel::Model code to determine primary key columns.
+* :type - The type of column, as a symbol (e.g. :string).  Used by the Sequel::Model typecasting code.
+
+Example:
+
+  DB.schema(:table) # [[:column1, {:allow_null=>true, :db_type=>'varchar(255)', :default=>'blah', :primary_key=>false, :type=>:string}], ...]
+
+== Column Information for a Model
+
+Model#db_schema returns pretty much the same information, except it returns it as a hash with column keys instead of an array of two element arrays.
+
+  Model.db_schema # {:column1=>{:allow_null=>true, :db_type=>'varchar(255)', :default=>'blah', :primary_key=>false, :type=>:string}, ...}
+
+== Columns used by a dataset/model
+
+Dataset#columns returns the columns of the current dataset as an array of symbols:
+
+  DB[:table].columns # [:column1, :column2, :column3, ...]
+
+Dataset#columns! does the same thing, except it ignores any cached value.  In general, the cached value should never be incorrect, unless the database schema is changed after the dataset is created.
+
+  DB[:table].columns! # [:column1, :column2, :column3, ...]
+
+Model.columns does the same thing as Dataset#columns, using the model's dataset:
+
+  Model.columns # [:column1, :column2, :column3, ...]
+
+== Associations Defined
+
+Sequel::Model offers complete introspection capability for all associations.
+
+You can get an array of association symbols with Model.associations:
+
+  Model.associations # [:association1, :association2, ...]
+
+You can get the association reflection for a single association via the Model.association_reflection.  Association reflections are subclasses of hash, for ease of use and introspection (and backwards compatibility):
+
+  Model.association_reflection(:association1) # {:name=>:association1, :type=>:many_to_one, :model=>Model, :associated_class=>OtherModel, ...}
+
+You can get an array of all association reflections via Model.all_association_reflections:
+
+  Model.all_association_reflections # [{:name=>:association1, :type=>:many_to_one, :model=>Model, :associated_class=>OtherModel, ...}, ...]
+
+Finally, you can get a hash of association reflections via Model.association_reflections:
+
+  Model.association_reflections # {:association1=>{:name=>:association1, :type=>:many_to_one, :model=>Model, :associated_class=>OtherModel, ...}, ...}

data/doc/release_notes/3.1.0.txt

@@ -0,0 +1,406 @@
+New Plugins
+-----------
+
+3 new plugins were added that implement features supported by
+DataMapper: identity_map, tactical_eager_loading, and
+lazy_attributes.  These plugins don't add any real new features, 
+since you can do most of what they allow before simply by being
+a little more explicit in your Sequel code. However, some people
+prefer a less explicit approach that uses a bit more magic, and
+now Sequel can accomodate them.
+
+* The identity_map plugin allows you to create a 1-1
+  correspondence of model objects to database rows via a temporary
+  thread-local identity map.  It makes the following statment true:
+
+    Sequel::Model.with_identity_map do
+      Album.filter{(id > 0) & (id < 2)}.first.object_id == \
+        Album.first(:id=>1).object_id
+    end
+
+  As the code above implies, you need to use the with_identity_map
+  method with a block to use the identity mapping feature.
+
+  By itself, identity maps don't offer much, but Sequel uses them
+  as a cache when looking up objects by primary key or looking up
+  many_to_one associated objects.  Basically, it can be used as a
+  performance enhancer, and it also allows the support of the
+  lazy_attributes plugin.
+
+  The identity_map plugin is expected to be most useful in web
+  applications.  With that in mind, here's a Rack middleware that
+  wraps each request in a with_identity_map call, so the
+  identity_map features are available inside the web app:
+
+    Sequel::Model.plugin :identity_map
+    class SequelIdentityMap
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        Sequel::Model.with_identity_map{@app.call(env)}
+      end
+    end
+
+* The tactical_eager_loading plugin allows you to eagerly load an
+  association for all models retrieved in the same group whenever
+  one of the models accesses the association:
+
+    # 2 queries total
+    Album.filter{id<100}.all do |a|
+      a.artists
+    end
+
+  In order for this correctly, you must use Dataset#all to load the
+  records, you cannot iterate over them via Dataset#each.  This is
+  because eager loading requires that you have all records in
+  advance, and when using Dataset#each you cannot know about later
+  records in the dataset.
+
+  Before, you could just be explicit about the associations you
+  needed and make sure to eagerly load them using eager before
+  calling Dataset#all.
+
+* The lazy_attributes plugin builds on the identity_map and
+  tactical_eager_loading plugins and allows you to create
+  attributes that are lazily loaded from the database:
+
+    Album.plugin :lazy_attributes, :review
+
+  This will remove the :review attribute from being selected by
+  default.  If you try to access the attribute after it is selected,
+  it'll retrieve the value from the database.  If the object was
+  retrieved with a group of other objects and an identity map is in
+  use, it'll retrieve the lazy attribute for the entire group of
+  objects at once, similar to the tatical_eager_loading plugin:
+
+    # 2 queries total
+    Sequel::Model.with_identity_map do
+      Album.filter{id<100}.all do |a|
+        a.review
+      end
+    end
+
+  Before, you could just set the default selected columns for a model
+  to not include the lazy attributes, and just use select_more to
+  add them to any query where the resulting model objects will
+  need the attributes.
+
+* A many_through_many plugin was also added.  This very powerful
+  plugin allows you to create associations to multiple objects through
+  multiple join tables.  Here are some examples:
+
+    # Assume the following many to many associations:
+    Artist.many_to_many :albums
+    Album.many_to_many :tags
+
+    # Same as Artist.many_to_many :albums
+    Artist.many_through_many :albums,
+      [[:albums_artists, :artist_id, :album_id]]
+
+    # All tags associated to any album this artist is associated to
+    Artist.many_through_many :tags,
+      [[:albums_artists, :artist_id, :album_id],
+       [:albums, :id, :id],
+       [:albums_tags, :album_id, :tag_id]]
+
+    # All artists associated to any album this artist is associated to
+    Artist.many_through_many :artists,
+      [[:albums_artists, :artist_id, :album_id],
+       [:albums, :id, :id],
+       [:albums_artists, :album_id, :artist_id]]
+
+    # All albums by artists that are associated to any album this
+    # artist is associated to
+    Artist.many_through_many :artist_albums,
+      [[:albums_artists, :artist_id, :album_id],
+       [:albums, :id, :id],
+       [:albums_artists, :album_id, :artist_id],
+       [:artists, :id, :id],
+       [:albums_artists, :artist_id, :album_id]]
+
+  Basically, for each join table between this model and the
+  associated model, you use an array with a join table name, left key
+  name (key closer to this model), and right key name (key closer to
+  the associated model).
+
+  In usual Sequel fashion, this association type works not just
+  for single objects, but it can also be eagerly loaded via eager or
+  eager_graph.  There are numerous additional configuration options,
+  please see the RDoc for details.
+
+New bin/sequel Features
+-----------------------
+
+The bin/sequel command line tool now supports the following options:
+
+* -C: Copies one database to another.  You must specify two database
+  arguments.  Works similar to Taps, copying the table schema, then
+  the table data, then creating the indexes.
+
+* -d: Dump the schema of the database in the database-independent
+  migration format.
+
+* -D: Dump the schema of the database in the database-specific
+  migration format.
+
+* -h: Display the help
+
+* -t: Output the full backtrace if an exception is raised
+
+The bin/sequel tool is now better about checking which options can
+be used together.  It also now supports using the -L option multiple
+times and having it load model files from multiple directory trees.
+
+New Features
+------------
+
+* Dataset#qualify_to and #qualify_to_first_source were added.  They
+  allow you to qualify unqualified columns in the current dataset
+  to the given table or the first source. This can be used to join
+  a dataset that has unqualified columns to a new table which has
+  columns with the same name.
+  
+  For example, take this dataset:
+  
+    ds = DB[:albums].select(:name).order(:name).filter(:id=>1)
+    # SELECT name FROM albums WHERE (id = 1) ORDER BY name
+
+  Let's say you want to join it to the artists table:
+  
+    ds2 = ds.join(:artists, :id=>:artist_id)
+    # SELECT name FROM albums 
+    #  INNER JOIN artists ON (artists.id = albums.artist_id)
+    #  WHERE (id = 1) ORDER BY name
+    
+  That's going to give you an error, as the artists table already has
+  columns named id and name.  This new feature allows you to do the
+  following:
+  
+    ds2 = ds.qualify_to_first_source.join(:artists, :id=>:artist_id)
+    # SELECT albums.name FROM albums
+    #  INNER JOIN artists ON (artists.id = albums.artist_id)
+    #  WHERE (albums.id = 1) ORDER BY albums.name
+    
+  By doing this, all unqualified columns are qualified, so you get
+  a usable query.  This is expected to be most useful for users that
+  have a default order or filter on their models and want to join
+  the model to another table.  Before you had to replace the filters,
+  selection, etc. manually, or use qualified columns by default even
+  though the weren't needed in most cases.
+
+* Savepoints are now supported using SQLite and MySQL, assuming you
+  are using a database version that supports them.  You need to
+  pass the :savepoint option to Database#transaction to use a
+  savepoint.
+
+* Model plugins can now depend on other plugins, simply by calling
+  the Model.plugin method inside the plugin's apply method:
+
+    module LazyAttributes
+      def self.apply(model)
+        model.plugin :tactical_eager_loading
+      end
+
+* Model.plugin now takes a block with is passed to the plugin's
+  apply and configure method (see Backwards Compatibility section for
+  more information on the configure method).
+
+* You can see which plugins are loaded for a model by using
+  Model.plugins.
+
+* You can use Sequel.extension method to load extensions:
+
+    Sequel.extension :pagination, :query
+
+  This will only load extensions that ship with Sequel, unlike the
+  Model.plugin method which will also load external plugins.
+
+* You can now use Database#create_table? to create the table if it
+  doesn't already exist (a very common need, it seems).  The schema
+  plugin now supports Model.create_table? as well.
+
+* #sql_subscript is now an allowed method on most SQL expression
+  objects that Sequel generates.  Also, arguments to #sql_subscript
+  can now be other expressions instead of just integers.
+
+* Associations can now take a :cartesian_product_number option, which
+  can be used to tell Sequel whether to turn on duplicate object
+  detection when eagerly loading objects through eager_graph.  This
+  number should be 0 if the association can never create multiple
+  rows for each row in the current table, 1 if it can create multiple
+  rows in the each row in the current table, and 2 if the association
+  itself causes a cartesian product.
+
+* On MySQL, Dataset#insert_ignore now affects #insert as well as
+  multi_insert and import.
+
+* Database#create_table now supports an :ignore_index_errors option,
+  and Database#add_index now supports an :ignore_errors option.
+  These are used by the schema_dumper when dumping an database
+  schema to be restored on another database type, since indexes
+  aren't usually required for proper operation and some indexes
+  can't be transferred.
+
+* The ADO adapter now takes a :provider option, which can be used
+  to set the provider.
+
+* The ADO adapter now takes a :command_timeout option, which tells
+  the connection how long to wait before giving up and raising an
+  exception.
+
+* The Sequel.amalgalite adapter method was added.  Like the
+  Sequel.sqlite method, you can call it with no arguments to get
+  an in memory database.
+
+Other Improvements
+------------------
+
+* MySQL "commands out of sync" errors should no longer occur unless
+  you are nesting queries (calling Dataset#each inside Dataset#each).
+  A bug dating at least to 2007 and possibly since the initial
+  creation of the Sequel MySQL adapter was the cause.  Before, SQL
+  that caused a result set that was sent using a method where Sequel
+  doesn't yield a result set would cause the "commands out of sync"
+  error on the following query.  For example, the following code
+  would cause the error:
+
+    DB << "SHOW DATABASES"
+
+  If for some reason a "commands out of sync" error does occur,
+  Sequel will disconnect the connection from the connection pool,
+  so it won't continually stay in the pool and raise errors every
+  time it is used.
+
+* The schema_dumper extension is much better about parsing defaults
+  from the database.  It can now correctly parse most defaults on
+  MySQL, SQLite, and PostgreSQL databases.  It no longer includes
+  defaults that it can't parse to a ruby object unless a database-
+  specific dump is requested.
+
+* The schema_dumper extension now dumps tables in alphabetical order.
+
+* Ordered and limited datasets are now handled correctly when using
+  union, intersect, and except.  Also, union, intersect, and except
+  now always return a from_self dataset, so further limiting,
+  filtering, and ordering of them now works as expected.
+
+* Dataset#graph now works correctly with a complex dataset without
+  having to use from_self.  Before, code like the following didn't
+  do what was expected:
+
+    DB[:albums].
+      graph(DB[:artists].filter{name > 'M'}, :id=>:artist_id)
+
+  Before, the filter on DB[:artists] would be dropped.  Now, Sequel
+  correctly uses a subselect.
+
+* You can now specify serialization formats per column in the
+  serialization plugin, either by calling the plugin multiple
+  times or by using the new serialize_attributes method:
+
+    Album.plugin :serialization
+    Album.serialize_attributes :marshal, :review
+    Album.serialize_attributes :yaml, :name
+    Album.serialization_map #{:name=>:yaml, :review=>:marshal}
+
+  The public API for the serialization plugin is still backwards
+  compatible, but the internals have changed slightly to support
+  this new feature.
+
+* You can now use eager_graph to eagerly load associations for models
+  that lack primary keys.
+
+* The :eager_graph association option now works when lazily-loading
+  many_to_many associations.
+
+* Dataset#add_graph_aliases now works correctly even if
+  set_graph_aliases hasn't been used.
+
+* The PostgreSQL Database#tables method now assumes the public schema
+  if a schema is not given and there is no default_schema.
+
+* The PostgreSQL Database#indexes method no longer returns partial
+  indexes or functional indexes.
+  
+* The MySQL Database#indexes method no longer returns indexes on
+  partial columns (prefix indexes).
+
+* Default values for String :text=>true and File columns on MySQL
+  are ignored, since MySQL doesn't support them.  They are not
+  ignored if you use text and blob, since then you are using the
+  database-specific syntax and Sequel doesn't do translation when
+  the database-specific syntax is used.
+
+* On PostgreSQL, attempting the reset the primary key sequence for a
+  table without a primary key no longer causes an error.
+
+* Using a placeholder string in an association's :condition option
+  now works correctly (e.g. :conditions=>['n = ?', 1])
+
+* An error is no longer raised if you attempt to load a plugin that
+  has a DatasetMethods module but no public dataset methods.
+
+* The check for dataset[n] where n is an integer was fixed.  It now
+  raises an error inside of returning a limited dataset.
+
+* On PostgreSQL, Dataset#insert with static SQL now works correctly.
+
+* A reflection.rdoc file was added giving an overview of Sequel's
+  reflection support.
+
+* The Migrator now works correctly with file names like
+  001_12312412_file_name.rb.
+
+* The association code now requires the classes match when looking
+  for a reciprocal association.
+
+* An unlikely threading bug (race condition) was possible when using
+  the validation_class_methods plugin. The plugin was refactored and
+  now uses a mutex to avoid the issue.  One of the refactoring changes
+  makes it so that you can no longer use a class level vaildation
+  inside a Class.new block (since inherited isn't called until the
+  block finishes).
+
+* The exception messages when Sequel.string_to_* fail have been fixed.
+
+* The String :text=>true generic database type has been fixed when
+  using the Firebird adapter.
+
+Backwards Compatibility
+-----------------------
+
+* A plugin's apply method is now only called the first time a plugin
+  is loaded.  Plugins can now have a configure method that is called
+  every time the plugin is loaded, and is always called after the
+  instance methods, class methods, and dataset method submodules have
+  been added to the model.  This is different from apply, which is
+  called before the submodules are loaded.
+
+  If you are a plugin author, please check your implementation to
+  make sure this doesn't cause problems for you.  If you have
+  questions, please post on the Sequel mailing list.
+
+  This new plugin feature will make certain things a lot easier, and
+  it should be mostly backwards compatible.  However, if a plugin
+  was previously expected to be loaded multiple times with the apply
+  method called each time, it will no longer work correctly.
+
+* The plugin_opts methods defined now include multiple args in an
+  array if multiple args are given.  Before, the plugin_opts methods
+  just returned the first argument.
+
+* Database#table_exists? no longer checks the cached schema
+  information.  By default, it will always do a database query
+  (unless overridden in an adapter).  This shouldn't affect the
+  results, but if were using the method a lot and expecting it to
+  use cached information, it doesn't have the same performance
+  characteristics.
+
+* The internal storage of the :select option for datasets have
+  changed.  You can no longer use a hash as a way of aliasing
+  columns.  Dataset#select now does the translation from the hash to
+  SQL::AliasedExpression instances.  Basically, if you were using
+  Dataset#clone directly with a :select option with hashes for
+  aliasing, you should switch to using Dataset#select or changing
+  the hashes to AliasedExpressions yourself.