viking-sequel 3.10.0

data/doc/release_notes/2.9.0.txt

@@ -0,0 +1,97 @@
+New Features
+------------
+
+* Compound SQL statement (i.e. UNION, EXCEPT, and INTERSECT) support
+  is much improved.  Chaining compound statement calls now longer
+  wipes out previous compound statements calls of the same type.
+  Also, the ordering of the compound statements is no longer fixed
+  per adapter, it now reflects the order they were called on the
+  object.  For example, the following now work as expected:
+
+    ds1.union(ds2).union(ds3)
+    ds1.except(ds2).except(ds3)
+    ds1.intersect(ds2).intersect(ds3)
+    ds1.union(ds2).except(ds3)
+    ds1.except(ds2).intersect(ds3)
+    ds1.intersect(ds2).union(ds3)
+
+* Exception classes ValidationFailure and BeforeHookFailure were
+  added so it is eaiser to catch a failed validation.  These are
+  both subclasses of Sequel::Error, so there shouldn't be any
+  backwards compatibility issues.  Error messages are also improved,
+  as the ValidationFailure message is a string containing all
+  validation failures and the BeforeHookFailure message contains
+  which hook type caused the failure (i.e. before_save,
+  before_create, or before_validate).
+
+* The sequel command line tool now has a -L option to load
+  all files in the given directory.  This is mainly useful for
+  loading a directory of model files. The files are loaded
+  after the database connection is set up.
+
+* Methods to create and drop database functions, triggers, and
+  procedural languages were added to the PostgreSQL adapter.
+
+Other Improvements
+------------------
+
+* Database#schema now raises an error if you pass a table that
+  doesn't exist.  Before, some adapters would return an empty schema.
+  The bigger problem with this is that it made table_exists? return
+  the wrong value, since it looks at the Database's schema.
+  Generally, this bug would show up in the following code:
+
+    class Blah < Sequel::Model
+    end
+    Blah.table_exists? # True even if blahs is not a table
+
+* AlterTableGenerator#add_foreign_key now works for MySQL.
+
+* Error messages in model association methods that add/remove an
+  associated object are now more descriptive.
+
+* Dataset#destroy for model datasets now works with databases that
+  can't handle nested queries.  However, it now loads all model
+  objects being destroyed before attempting to destroy any of them.
+
+* Dataset#count now works correctly for compound SQL statements
+  (i.e. UNION, EXCEPT, and INTERSECT).
+
+* BigDecimal NaN and (+/-)Infinity values are now literalized
+  correctly.  Database support for this is hit or miss.  Sqlite will
+  work correctly, PostgreSQL raises an error if you try to store an
+  infinite value in a numeric column (though it works for float
+  columns), and MySQL converts all three to 0.
+
+* The SQLite adapter no longer loses primary key information when
+  dropping columns.
+
+* The SQLite adapter now supports dropping indicies.
+
+* A bug in the MSSQL adapter's literalization of LiteralStrings has
+  been fixed.
+
+* The literalization of blobs on PostgreSQL (bytea columns) has been
+  fixed.
+
+* Sequel now raises an error if you attempt to subclass Sequel::Model
+  before setting up a database connection.
+
+* The native postgresql adapter has been changed to only log client
+  messages of level WARNING by default.  You can modify this via:
+
+    Sequel::Postgres.client_min_messages = nil # Use Server Default
+    Sequel::Postgres.client_min_messages = :notice # Use NOTICE level
+
+* Model#inspect now calls Model#inspect_values for easier
+  overloading.
+
+Backwards Compatibilty
+----------------------
+
+* The API to Model#save_failure (a private method) was changed to
+  remove the second argument.
+
+* SQLite columns with type numeric, decimal, or money are now
+  returned as BigDecimal values.  Before, they were probably returned
+  as strings.

data/doc/release_notes/3.0.0.txt

@@ -0,0 +1,221 @@
+Deprecated Methods/Features Removed
+-----------------------------------
+
+Methods and features that were deprecated in 2.12.0 have been removed
+in 3.0.0.  Many features were moved into plugins or extensions, so in
+many cases you just need to require an extension or use Model.plugin
+and not make any changes to your code.  See the 2.12.0 release notes
+for the list of methods/features deprecated in 2.12.0.
+
+If you are upgrading from a previous 2.x release, please upgrade to
+2.12.0 first, fix your code to remove all deprecation warnings, and
+then upgrade to 3.0.0.
+
+New Adapter
+-----------
+
+* Sequel now has an Amalgalite adapter.  Amalgalite is a ruby
+  extension that embeds SQLite without requiring a separate SQLite
+  installation.  The adapter is functionality complete but
+  significantly slower than the native SQLite adapter.
+
+New Features
+------------
+
+* The JDBC, PostgreSQL, MySQL, and SQLite adapters all now have a
+  Database#indexes method that returns indexes for a given table:
+
+    DB.indexes(:songs)
+    => {:songs_name_index=>{:unique=>true, :columns=>[:name]},
+        :songs_lyricid_index=>{:unique=>false, :columns=>[:lyricid]}}
+
+* A schema_dumper extension was added to Sequel.  It supports dumping
+  the schema of a table (including indexes) as a string that can be
+  evaluated in the context of a Database object to create the table.
+  It also supports dumping all tables in the database as a string
+  containing a Migration subclass that will rebuild the database.
+
+    require 'sequel/extensions/schema_dumper'
+    DB.dump_table_schema(:table)
+    DB.dump_schema_migration
+    DB.dump_schema_migration(:same_db=>true)
+    DB.dump_schema_migration(:indexes=>false)
+    DB.dump_indexes_migration
+
+  The :same_db option causes Sequel to not translate column types
+  to generic column types.  By default, the migration created will
+  use generic types so it will run on other databases.  However, if
+  you only want to support a single database, using the :same_db
+  option will make the migration use the exact database type parsed
+  from the database.
+
+  The :indexes=>false option causes indexes not be included in the
+  migration.  The dump_indexes_migration can be used to create a
+  separate migration with the indexes.  This can be useful if you 
+  plan on loading a lot of data right after creating the tables,
+  since it is faster to add indexes after the data has been added.
+
+* Using options with the generic database types is now supported to
+  a limited extent.  For example, the following code now works:
+
+    DB.create_table(:table) do
+      String :a, :size=>50               # varchar(50)
+      String :b, :text=>true             # text
+      String :c, :fixed=>true, :size=>30 # char(30)
+      Time :ts                           # timestamp
+      Time :t, :only_time=>true          # time
+    end
+
+* Using Dataset#filter and related methods with multiple arguments
+  now works much more intuitively:
+
+    # 2.12.0
+    dataset.filter(:a, :b=>1) # a IS NULL AND (b = 1) IS NULL
+    # 3.0.0
+    dataset.filter(:a, :b=>1) # a AND b = 1
+
+* You can now create temporary tables by passing the :temp=>true
+  option to Database#create_table.
+
+* The Oracle shared adapter now supports emulation of
+  autoincrementing primary keys by creating a sequence and a trigger,
+  similar to how the Firebird adapter works.
+
+* The Database#database_type method was added that returns a symbol
+  specifying the database type being used.  This can be different
+  than Database.adapter_scheme if you are using an adapter like
+  JDBC that allows connecting to multiple different types of
+  databases.
+
+* Database#drop_index and related methods now support an options
+  hash that respects the :name option, so they can now be used to
+  drop an index that doesn't use the default index name.
+
+* The PostgreSQL shared adapter now supports a
+  Database#reset_primary_key_sequence method to reset the
+  primary key sequence for a given table, based on code from
+  ActiveRecord.
+
+* SQL::QualifiedIdentifiers can now be qualified, allowing you to do:
+
+   :column.qualify(:table).qualify(:schema)
+ 
+* Using the :db_type=>'mssql' option with the DBI adapter will now
+  load the MSSQL support.
+
+* The MySQL shared adapter now supports Dataset#full_text_sql, which
+  you can use in queries like the following:
+
+    ds.select(:table.*, ds.full_text_sql(:column, 'value').as(:ft))
+
+Other Improvements
+------------------
+
+* Sequel will now release connections from the connection pool
+  automatically if they are held by a dead thread.  This can happen
+  if you are using MRI 1.8 and you are heavily multithreaded or
+  you call Thread#exit! or similar method explicitly.  Those methods
+  skip the execution of ensure blocks which normally release the
+  connections when the threads exit.
+
+* Model#save will now always use the same server when refreshing data
+  after an insert.  This fixes an issue when Sequel's master/slave
+  database support is used with models.
+
+* SQL Array references are now quoted correctly, so code like this
+  now works:
+
+    :table__column.sql_subscript(1)
+
+* The PostgreSQL shared adapter now handles sequences that need to be
+  quoted correctly (previously these were quoted twice).
+
+* String quoting on Oracle no longer doubles backslashes. 
+
+* Database#count now works correctly when used on MSSQL when using
+  an adapter that doesn't handle unnamed columns.
+
+* Full text searching in the MySQL adapter now works correctly when
+  multiple search terms are used.
+
+* Altering a column's name, type, default, or NULL/NOT NULL status
+  on MySQL now keeps other relevent column information.  For example,
+  if you alter a column's type, it'll keep an existing default. This
+  functionality isn't complete, there may be other column information
+  that is lost.
+
+* Fix creation of an index with a given type on MySQL, since MySQL's
+  documentation lies.
+
+* The schema parser now handles decimal types with size specifiers,
+  fixing use on MySQL.
+
+* Dataset#quote_identifier now works correctly when given an
+  SQL::Identifier.  This allows you to do:
+
+    dataset.select{sum(hours).as(hours)}
+
+Backwards Compatibility
+-----------------------
+
+* Sequel will now use instance_eval on all virtual row blocks without
+  an argument.  This can lead to much nicer code:
+
+    dataset.filter{(number > 10) & (name > 'M')}
+    # WHERE number > 10 AND name > 'M'
+
+  2.12.0 raised a deprecation warning if you used a virtual row block
+  without an argument and you hadn't set
+  Sequel.virtual_row_instance_eval = true.
+
+* Dataset#exclude now inverts the given argument, instead of negating
+  it. This only changes its behavior if it is called with a hash or
+  array of all two pairs that have more than one element.
+
+    # 2.12.0
+    dataset.exclude(:a=>1, :b=>1) # a != 1 AND b != 1
+    # 3.0.0
+    dataset.exclude(:a=>1, :b=>1) # a != 1 OR b != 1
+
+  This was done for consistency, since exclude would only negate a
+  hash if it was given an argument, it would invert the same hash
+  if you used a block:
+
+    # 2.12.0
+    dataset.exclude{{:a=>1, :b=>1}} # a != 1 OR b != 1
+  
+  If you want the previous behavior,
+  change the code to the following:
+
+    dataset.filter({:a=>1, :b=>1}.sql_negate)
+
+* As noted above, the methods/features deprecated in 2.12.0 were
+  removed.
+
+* The private Dataset#select_*_sql methods now only take a single
+  argument, the SQL string being built.
+
+* Dataset#from when called without arguments would previously cause an
+  error to be raised when the SQL string is generated.  Now it causes
+  no FROM clause to be used, similar to how Dataset#select with no
+  arguments causes SELECT * to be used.
+
+* The internals of the generic type support and the schema generators
+  were changed significantly, which could have some fallout in terms
+  of old migrations breaking if they used the generic types and were
+  relying on some undocumented behavior (such as using Integer as a
+  type with the :unsigned option).
+
+* The Firebird adapter no longer translates the text database
+  specific type.  Use the following instead:
+    
+    String :column, :text=>true 
+
+* The MySQL shared adapter used to use the timestamp type for Time,
+  now it uses datetime.  This is because the timestamp type cannot
+  represent everything that the ruby Time class can represent.
+
+* Metaprogramming#metaattr_accessor and #metaattr_reader methods were
+  removed.
+
+* Dataset#irregular_function_sql was removed.

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.