sequel 3.21.0 → 3.39.0

data/doc/release_notes/3.23.0.txt

@@ -0,0 +1,172 @@
+= New Features
+
+* Sequel now allows dynamic customization for eager loading.
+  Previously, the parameters for eager loading were fixed at
+  association creation time.  Now, they can be modified at query
+  time.  To dynamically modify an eager load, you use a hash with
+  the proc as the value. For example, if you have this code:
+
+    Artist.eager(:albums)
+
+  And you only want to eagerly load albums where the id is greater
+  than or equal to some number provided by the user, you do:
+
+    min = params[:min].to_i
+    Artist.eager(:albums=>proc{|ds| ds.where{id > min}})
+    
+  This also works when eager loading via eager_graph:
+  
+    Artist.eager_graph(:albums=>proc{|ds| ds.where{id > min}})
+  
+  For eager_graph, the dataset is the dataset to graph into the
+  current dataset, and filtering it will result in an SQL query
+  that joins to a subquery.
+  
+  You can also use dynamic customization while cascading to also
+  eagerly load dependent associations, by making the hash value
+  a single entry hash with a proc key and the value being the
+  dependent associations to eagerly load. For example, if you want
+  to eagerly load tracks for those albums:
+
+    Artist.eager(:albums=>{proc{|ds| ds.where{id > min}}=>:tracks})
+
+* Sequel also now allows dynamic customization for regular
+  association loading.  Previously, this was possible by using the
+  association's dataset:
+
+    albums = artist.albums_dataset.filter{id > min}
+
+  However, then there was no handling of caching, callbacks, or
+  reciprocals.  For example:
+
+    albums.each{|album| album.artist}
+    
+  Would issue one query per album to get the artist, because the
+  reciprocal association was not set.  Now you can provide a
+  block to the association method:
+  
+    albums = artist.albums{|ds| ds.filter{id > min}}
+    
+  This block is called with the dataset used to retrieve the
+  associated objects, and should return a modified version of that
+  dataset.
+  
+  Note that ruby 1.8.6 doesn't allow blocks to take block arguments,
+  so you have to pass the block as a separate proc argument to the
+  association method if you are still using 1.8.6.
+
+* Sequel now supports filtering by associations.  This wasn't
+  previously supported as filtering is a dataset level feature and
+  associations are a model level feature, and datasets do not depend
+  on models.  Now, model datasets have the ability to filter by
+  associations.  For example, to get all albums for a given artist,
+  you could do:
+  
+    artist = Artist[1]
+    Album.filter(:artist=>artist)
+    
+  Since the above can also be accomplished with:
+  
+    artist.albums
+    
+  this may not seem like a big improvement, but it allows you to
+  filter on multiple associations simultaneously:
+  
+    Album.filter(:artist=>artist, :publisher=>publisher)
+    
+  For simple many_to_one associations, the above is just a simpler
+  way to do:
+  
+    Album.filter(:artist_id=>artist.id, :publisher_id=>publisher.id)
+    
+  Sequel supports this for all association types, including
+  many_to_many and many_through_many, where a subquery is used, and
+  it also works when composite key associations are used:
+  
+    Album.filter(:artist=>artist, :tags=>tag)
+    
+  This will give you the albums for that artist that are also tagged
+  with that tag.  To provide multiple values for the same
+  association, mostly useful for many_to_many associations, you can
+  either use separate filter calls or specify the conditions as an
+  array:
+  
+    Album.filter(:tags=>tag1).filter(:tags=>tag2)
+    Album.filter([[:tags, tag1], [:tags, tag2]])
+
+* A columns_introspection extension has been added that makes
+  datasets attempt to guess their columns in some cases instead of
+  issuing a database query.  This can improve performance in cases
+  where the columns are needed implicitly, such as graphing.  After
+  loading the extension, you can enable the support for specific
+  datasets by extending them with Sequel::ColumnIntrospection.  To
+  enable introspection for all datasets, use:
+  
+    Sequel::Dataset.introspect_all_columns
+
+* A serialization_modification_detection plugin has been added.
+  Previously, Sequel could not detect modifications made to
+  serialized objects.  It could detect modification if you assigned
+  a new value:
+  
+    model.hash_column = model.hash_column.merge(:foo=>:bar)
+    
+  but not if you just modified the object directly:
+  
+    model.hash_columns[:foo] = :bar
+    
+  With this plugin, such modifications can be detected, at a
+  potentially significant performance cost.
+
+= Other Improvements
+
+* When using a migration directory containing both older integer
+  migrations and newer timestamp migrations, where some integer
+  migrations have not been applied, make sure to apply the remaining
+  integer migrations before the timestamp migrations.  Previously,
+  they could be applied out of order due to a lexicographic sort
+  being used instead of a numeric sort.
+
+* If a model does not select all columns from its table, the
+  insert_select optimization is no longer used.  Previously,
+  creating a new model object for such a model could result in the
+  object containing columns that the model does not select.
+
+* You can now use :select=>[] as an option for many_to_many
+  associations to select all columns from both the associated
+  table and the join table.  Previously, this raised an error and
+  required you do :select=>'*'.lit as a workaround.  The default
+  remains to select all columns in the associated table and none
+  from the join table.
+
+* The xml_serializer plugin now handles namespaced models by
+  using __ instead of / as the namespace separator.  Previously, /
+  was used and caused problems as it is not valid XML.
+  
+* The :eager_grapher association option can now accept a proc that
+  takes a single hash of options instead of a fixed 3 arguments.
+  This is the recommended way going forward of writing custom
+  :eager_graphers, and all of the internal ones have been converted.
+  The previous way of using 3 arguments is still supported.
+  
+* A bug in the identity_map plugin for many_to_one associations
+  without full association reflection information has been fixed.
+
+* Sequel is now using GitHub Issues for issue tracking.  Old issues
+  have been migrated from Google Code.
+
+= Backwards Compatibility
+
+* The filter by associations support breaks backward compatibilty for
+  users who previously added an sql_literal instance method to
+  Sequel::Model.  Usually, that was done to for reasons similar to
+  but inferior than the filter by association support.  The following
+  code can be used as a temporary workaround until you can modify
+  your program to use the new filter by associations support:
+  
+    Sequel::Model::Associations::DatasetMethods.
+      send(:remove_method, :complex_expression_sql)
+
+* The private Sequel::Model#_load_associated_objects method now takes
+  an additional, optional options hash.  Plugins that override that
+  method need to be modified.

data/doc/release_notes/3.24.0.txt

@@ -0,0 +1,420 @@
+= Prepared Statement Plugins
+
+* The prepared_statements plugin makes Sequel::Model classes use
+  prepared statements for creating, updating, and destroying model
+  instances, as well as looking up model objects by primary key.
+  With this plugin, all of the following will use prepared
+  statements:
+  
+    Artist.plugin :prepared_statements
+    Artist.create(:name=>'Foo')
+    a = Artist[1]
+    a.update(:name=>'Bar')
+    a.destroy
+
+* The prepared_statements_safe plugin reduces the number of
+  prepared statements that can be created by doing two things. First,
+  it makes the INSERT statements used when creating instances to use
+  as many columns as possible, setting specific values for all
+  columns with parseable default values.  Second, it changes
+  save_changes to just use save, saving all columns instead of just
+  the changed ones.
+
+  The reason for this plugin is that Sequel's default behavior of
+  using only the values specifically set when creating instances
+  and having update only set changed columns by default can lead
+  to a large number of prepared statements being created.
+  
+  For prepared statements to be used, each set of columns in the
+  insert and update statements needs to have its own prepared
+  statement.  If you have a table with 1 primary key column and
+  4 other columns, you can have up to 2^4 = 16 prepared statements
+  created, one for each subset of the 4 columns.  If you have 1
+  primary key column and 20 other columns, there are over a million
+  subsets, and you could hit your database limit for prepared
+  statements (a denial of service attack).
+  
+  Using the prepared_statements_safe plugin mitigates this
+  issue by reducing the number of columns that may or may not be
+  present in the query, in many cases making sure that each model
+  will only have a single INSERT and a single UPDATE prepared
+  statement.
+
+* The prepared_statements_associations plugin allows normal
+  association method calls to use prepared statements if possible.
+  For example:
+  
+    Artist.plugin :prepared_statements_associations
+    Artist.many_to_one :albums
+    Artist[1].albums
+  
+  Will use a prepared statement to return the albums for that artist.
+  This plugin works for all supported association types.  There are
+  some associations (filtered and custom associations) that Sequel
+  cannot currently use a prepared statement reliably, for those
+  Sequel will use a regular query.
+
+* The prepared_statements_with_pk plugin allows the new
+  Dataset#with_pk method (explained below) to use prepared statements.
+  For example:
+  
+    Artist.plugin :prepared_statements_with_pk
+    Artist.filter(...).with_pk(1)
+  
+  Will use a prepared statement for this query.  The most benefit
+  from prepared statements come from queries that are expensive to
+  parse and plan but quick to execute, so using this plugin with
+  a complex filter can in certain cases yield significant performance
+  improvements.
+    
+  However, this plugin should be considered unsafe as it is possible
+  that it will create an unbounded number of prepared statements. It
+  extracts parameters from the dataset using Dataset#unbind
+  (explained below), so if your code has conditions that vary per
+  query but that Dataset#unbind does not handle, an unbounded number
+  of prepared statements can be created.  For example:
+  
+    Artist.filter(:a=>params[:b].to_i).with_pk[1]
+    Artist.exclude{a > params[:b].to_i}.with_pk[1]
+    
+  are safe, but:
+  
+    Artist.filter(:a=>[1, params[:b].to_i]).with_pk[1]
+    Artist.exclude{a > params[:b].to_i + 2}.with_pk[1]
+    
+  are not.  For queries that are not safe, Dataset#with_pk should
+  not be used with this plugin, you should switch to looking up by
+  primary key manually (for a regular query):
+  
+    Artist.filter(:a=>[1, params[:b].to_i])[:id=>1]
+  
+  or using the prepared statement API to create a custom prepared
+  statement:
+  
+    # PS = {}
+    PS[:name] ||= Artist.filter(:a=>[1, :$b], :id=>:$id).
+           prepare(:select, :name)
+    PS[:name].call(:b=>params[:b].to_i, :id=>1)
+    
+= Other New Features
+
+* Filtering by associations got a lot more powerful.  Sequel 3.23.0
+  introduced filtering by associations:
+  
+    Album.filter(:artist=>artist)
+    
+  This capability is much expanded in 3.24.0, allowing you to
+  exclude by associations:
+  
+    Album.exclude(:artist=>artist)
+    
+  This will match all albums not by that artist.
+    
+  You can also filter or exclude by multiple associated objects:
+  
+    Album.filter(:artist=>[artist1, artist2])
+    Album.exclude(:artist=>[artist1, artist2])
+    
+  The filtered dataset will match all albums by either of those
+  two artists, and the excluded dataset will match all albums not
+  by either of those two artists.
+  
+  You can also filter or exclude by using a model dataset:
+  
+    Album.filter(:artist=>Artist.filter(:name.like('A%'))).all
+    Album.exclude(:artist=>Artist.filter(:name.like('A%'))).all
+    
+  Here the filtered dataset will match all albums where the
+  associated artist has a name that begins with A, and the excluded
+  dataset will match all albums where the associated artist does not
+  have a name that begins with A.
+  
+  All of these types of filtering and excluding work with all of
+  association types that ship with Sequel, even the many_through_many
+  plugin.
+
+* Sequel now supports around hooks, which wrap the related before
+  hook, behavior, and after hook.  Like other Sequel hooks, these
+  are implemented as instance methods.  For example, if you wanted
+  to log DatabaseErrors raised during save:
+
+    class Artist < Sequel::Model
+      def around_save
+        super
+      rescue Sequel::DatabaseError => e
+        # log the error
+        raise
+      end
+    end
+    
+  All around hooks should call super, not yield.  If an around hook
+  doesn't call super or yield, it is treated as a hook failure,
+  similar to before hooks returning false.
+  
+  For around_validation, the return value of super should be whether
+  the object is valid.  For other around hooks, the return value of
+  super is currently true, but it's possible that will change in the
+  future.
+  
+* Dataset#with_pk has been added to model datasets that allows you
+  to find the object with the matching primary key:
+  
+    Artist.filter(:name.like('A%')).with_pk(1)
+    
+  This should make easier the common case where you want to find
+  a particular object that is associated to another object:
+  
+    Artist[1].albums_dataset.with_pk(2)
+
+  Before, there was no way to do that without manually specifying
+  the primary key:
+  
+    Artist[1].albums_dataset[:id=>2]
+    
+  To use a composite primary key with with_pk, you have to provide
+  an array:
+  
+    Artist[1].albums_dataset.with_pk([1, 2])
+    
+* Dataset#[] for model datasets will now call with_pk if given a
+  single Integer argument.  This makes the above case even easier:
+  
+    Artist[1].albums_dataset[2]
+    
+  Note that for backwards compatibility, this only works for
+  single integer primary keys.  If you have a composite primary key
+  or a string/varchar primary key, you have to use with_pk.
+
+* Dataset#unbind has been added, which allows you to take a dataset
+  that uses static bound values and convert them to placeholders.
+  Currently, the only cases handled are SQL::ComplexExpression
+  objects that use a =, !=, <, >, <=, or >= operator where the first
+  argument is a Symbol, SQL::Indentifier, or
+  SQL::QualifiedIdentifier, and the second argument is a Numeric,
+  String, Date, or Time.  Dataset#unbind returns a two element array,
+  where the first element is a modified copy of the receiver, and the
+  second element is a bound variable hash:
+  
+    ds, bv = DB[:table].filter(:a=>1).unbind
+    ds # DB[:table].filter(:a=>:$a)
+    bv # {:a=>1}
+
+  The purpose of doing this is that you can then use prepare or call
+  on the returned dataset with the returned bound variables:
+  
+    ds.call(:select, bv)
+    # SELECT * FROM table WHERE (a = ?); [1]
+    
+    ps = ds.prepare(:select, :ps_name)
+    # PREPARE ps_name AS SELECT * FROM table WHERE (a = ?)
+    ps.call(bv)
+    # EXECUTE ps_name(1)
+    
+  Basically, Dataset#unbind takes a specific statement and attempts
+  to turn it into a generic statement, along with the placeholder
+  values it extracted.
+  
+  Unfortunately, Dataset#unbind cannot handle all cases.  For
+  example:
+  
+    DB[:table].filter{a + 1 > 10}.unbind
+    
+  will not unbind any values.  Also, if you have a query with
+  multiple different values for a variable, it will raise an
+  UnbindDuplicate exception:
+  
+    DB[:table].filter(:a=>1).or(:a=>2).unbind
+
+* A defaults_setter plugin has been added that makes it easy to
+  automatically set default values when creating new objects.  This
+  plugin makes Sequel::Model behave more like ActiveRecord in that
+  new model instances (before saving) will have default values
+  parsed from the database.  Unlike ActiveRecord, only values with
+  non-NULL defaults are set.  Also, Sequel allows you to easily
+  modify the default values used:
+  
+    Album.plugin :default_values
+    Album.new.values # {:copies_sold => 0}
+    Album.default_values[:copies_sold] = 42
+    Album.new.values # {:copies_sold => 42}
+    
+  Before, this was commonly done in an after_initialize hook, but
+  that's slower as it is also called for model instances loaded from
+  the database.
+  
+* A Database#views method has been added that returns an array
+  of symbols representing view names in the database.  This works
+  just like Database#tables except it returns views.
+
+* A Sequel::ASTTransformer class was added that makes it easy to
+  write custom transformers of Sequel's internal abstract syntax
+  trees.  Dataset#qualify now uses a subclass of ASTTransformer to do
+  its transformations, as does the new Dataset#unbind.
+
+= Other Improvements
+
+* Database#create_table? now uses a single query with IF NOT EXISTS
+  if the database supports such syntax.  Previously, it issued a
+  SELECT query to determine table existence.  Sequel currently
+  supports this syntax on MySQL, H2, and SQLite 3.3.0+.
+  
+  The Database#supports_create_table_if_not_exists? method was added
+  to allow users to determine whether this syntax is supported.
+
+* Multiple column IN/NOT IN emulation now works correctly with
+  model datasets (or other datasets that use a row_proc).
+  
+* You can now correctly invert SQL::Constant instances:
+
+    Sequel::NULL # NULL
+    ~Sequel::NULL # NOT NULL
+    Sequel::TRUE # TRUE
+    ~Sequel::TRUE # FALSE
+
+* A bug in the association_pks plugin has been fixed in the case
+  where the associated table had a different primary key column name
+  than the current table.
+
+* The emulated prepared statement support now supports nil and false
+  as bound values.
+  
+* The to_dot extension was refactored for greater readability.  The
+  only change was a small fix in the display for SQL::Subscript
+  instances.
+
+* The Dataset#supports_insert_select? method is now available to let
+  you know if the dataset supports insert_select.  You should use
+  this method instead of respond_to? for checking for insert_select
+  support.
+  
+* Prepared statements/bound variable can now use a new :insert_select
+  type for preparing a statement that will insert a row and return
+  the row inserted, if the dataset supports insert_select.
+  
+* The Model#initialize_set private method now exists for easier plugin
+  writing.  It is only called for new model objects, with the hash
+  given to initialize.  By default, it just calls set.
+  
+* A small bug when creating anonymous subclasses of Sequel::Model on
+  ruby 1.9 has been fixed.
+  
+* If Thread#kill is used inside a transaction on ruby 1.8 or
+  rubinius, the transaction is rolled back.  This situation is not
+  handled correctly on JRuby or ruby 1.9, and I'm not sure it's
+  possible to handle correctly on those implementations.
+  
+* The postgres adapter now supports the
+  Sequel::Postgres::PG_NAMED_TYPES hash for associating conversion
+  procs for custom types that don't necessarily have the same type
+  oid on different databases.  This hash uses symbol keys and
+  proc values:
+  
+    Sequel::Postgres::PG_NAMED_TYPES[:interval] = proc{|v| ...}
+    
+  The conversion procs now use a separate hash per Database object
+  instead of a hash shared across all Database objects.  You
+  can now modify the types for a particular Database object, but
+  you have to use the type oid:
+  
+    DB.conversion_procs[42] = proc{|v| ...}
+
+* On SQLite and MSSQL, literalization of true and false values given
+  directly to Dataset#filter has been fixed.  So the following now
+  works correctly on those databases:
+  
+    DB[:table].filter(true)
+    DB[:table].filter(false)
+    
+  Unfortunately, because SQLite and MSSQL don't have a real boolean
+  type, these will not work:
+  
+    DB[:table].filter{a & true}
+    DB[:table].filter{a & false}
+    
+  You currently have to work around the issue by doing:
+  
+    DB[:table].filter{a & Sequel::TRUE}
+    DB[:table].filter{a & Sequel::FALSE}
+    
+  It is possible that a future version of Sequel will remove the need
+  for this workaround, but that requires having a separate
+  literalization method specific to filters.
+
+* The MySQL bit type is no longer treated as a boolean.  On MySQL, the
+  bit type is a bitfield, which is very different than the MSSQL bit
+  type, which is the closest thing to a boolean on MSSQL.
+  
+* The bool database type is now recognized as a boolean.  Some SQLite
+  databases use bool, such as the ones used in Firefox.
+  
+* SQL_AUTO_IS_NULL=0 is now set by default when connecting to MySQL
+  using the swift or jdbc adapters.  Previously, it was only set by
+  default when using the mysql or mysql2 adapters.
+
+* Dataset#limit now works correctly on Access, using the TOP syntax.
+
+* Dataset#limit now works correctly on DB2, using the FETCH FIRST
+  syntax.
+    
+* The jdbc mssql subadapter was split into separate subadapters for
+  sqlserver (using Microsoft's driver) and jtds (using the open
+  source JTDS driver).
+
+* The jdbc jtds subadapter now supports converting Java CLOB
+  objects to ruby strings.
+
+* Tables from the INFORMATION_SCHEMA are now ignored when parsing
+  schema on JDBC.
+
+* The informix adapter has been split into shared/specific parts, and
+  a jdbc informix subadapter has been added.
+
+* Dataset#insert_select now works correctly on MSSQL when the core
+  extensions are disabled.
+
+* The sqlite adapter now logs when preparing a statement.
+
+* You no longer need to be a PostgreSQL superuser to run the postgres
+  adapter specs.
+  
+* The connection pool specs are now about 10 times faster and not
+  subject to race conditions due to using Queues instead of
+  sleeping.
+
+= Backwards Compatibility
+
+* Model#save no longer calls Model#valid?.  It now calls the
+  Model#_valid? private method that Model#valid? also calls.  To mark
+  a model instance invalid, you should override the Model#validate
+  method and add validation errors to the object.
+
+* The BeforeHookFailure exception class has been renamed to
+  HookFailure since hook failures can now be raised by around hooks
+  that don't call super.  BeforeHookFailure is now an alias to
+  HookFailure, so no code should break, but you should update your
+  code to reflect the new name.
+
+* Any custom argument mappers used for prepared statements now need
+  to implement the prepared_arg? private instance method and have it
+  return true.
+
+* If your databases uses bit as a boolean type and isn't MSSQL, it's
+  possible that those columns will no longer be treated as booleans.
+  Please report such an issue on the bugtracker.
+  
+* It is possible that the filtering and excluding by association
+  datasets will break backwards compatibility in some apps.  This can
+  only occur if you are using a symbol with the same name as an
+  association with a model dataset whose model is the same as the
+  associated class.  As associations almost never have the same names
+  as columns, this would require either aliasing or joining to
+  another table.  If for some reason this does break your app, you
+  can work around it by changing the symbol to an SQL::Identifier or
+  a literal string.
+
+* The Sequel::Postgres.use_iso_date_format= method now only affects
+  future Database objects.
+
+* On MySQL, Database#tables no longer returns view names, it only
+  returns table names.  You have to use Database#views to get view
+  names now.

data/doc/release_notes/3.25.0.txt

@@ -0,0 +1,88 @@
+= New Features
+
+* drop_table, drop_view, drop_column, and drop_constraint all now
+  support a :cascade option for using CASCADE.
+  
+    DB.drop_table(:tab, :cascade=>true)
+    # DROP TABLE tab CASCADE
+    
+    DB.drop_column(:tab, :col, :cascade=>true)
+    # ALTER TABLE tab DROP COLUMN col CASCADE
+    
+  A few databases support CASCADE for dropping tables and views,
+  but only PostgreSQL appears to support it for columns and
+  constraints.  Using the :cascade option when the underlying
+  database doesn't support it will probably result in a
+  DatabaseError being raised.
+
+* You can now use datasets as expressions, allowing things such as:
+  
+    DB[:table1].select(:column1) > DB[:table2].select(:column2)
+    # (SELECT column1 FROM table1) > (SELECT column2 FROM table2)
+
+    DB[:table1].select(:column1).cast(Integer)
+    # CAST((SELECT column1 FROM table1) AS integer)
+
+* Dataset#select_group has been added for grouping and selecting on
+  the same columns.
+  
+    DB[:a].select_group(:b, :c)
+    # SELECT b, c FROM a GROUP BY b, c
+
+* Dataset#exclude_where and #exclude_having methods have been added,
+  allowing you to specify which clause to affect.  #exclude's
+  behavior is still to add to the HAVING clause if one is present,
+  and use the WHERE clause otherwise.
+  
+* Dataset#select_all now accepts optional arguments and will select
+  all columns from those arguments if present:
+  
+    DB[:a].select_all(:a)
+    # SELECT a.* FROM a
+    
+    DB.from(:a, :b).select_all(:a, :b)
+    # SELECT a.*, b.* FROM a, b
+
+* Dataset#group and #group_and_count now both accept virtual row
+  blocks:
+  
+    DB[:a].select(:b).group{c(d)}
+    # SELECT b FROM a GROUP BY c(d)
+
+* If you use a LiteralString as a validation error message, 
+  Errors#full_messages will now not add the related column name to
+  the start of the error message.
+
+* Model.set_dataset now accepts SQL::Identifier,
+  SQL::QualifiedIdentifier, and SQL::AliasedExpression instances,
+  treating them like Symbols.
+  
+= Other Improvements
+
+* The association_pks plugin's setter method will now automatically
+  convert a given array of strings to an array of integers if the
+  primary key field is an integer field, which should make it easier
+  to use in web applications.
+  
+* nil bound variable, prepared statement, and stored procedure
+  arguments are now handled correctly in the JDBC adapter.
+
+* On 1.9, you can now load plugins even when ::ClassMethods,
+  ::InstanceMethods, or ::DatasetMethods is defined.
+
+= Backwards Compatibility
+
+* The tinytds adapter now only works with tiny_tds 0.4.5 and greater.
+  Also, if you were using the tinytds adapter with FreeTDS 0.91rc1,
+  you need to upgrade to FreeTDS 0.91rc2 for it to work.  Also, if
+  you were referencing an entry in the freetds.conf file, you now
+  need to specify it directly using the :dataserver option when
+  connecting, the adapter no longer copies the :host option to the
+  :dataserver option.
+
+* On postgresql, Sequel now no longer drops tables with CASCADE by
+  default.  You now have to use the :cascade option to drop_table if
+  you want to use CASCADE.
+
+* The Database#drop_table_sql private method now takes an additional
+  options hash argument.