sequel 4.9.0 → 4.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54a1904977f9d5f4de5e523dbd0ba244e8ef6203
-  data.tar.gz: 404f40b96e9fc774587485c727186aa6ab2c54b7
+  metadata.gz: d32a56c879a430a1257dd8e5f13e7346a4fe52bc
+  data.tar.gz: 5dd875255c904b9b4a26e8b62c8beb1e31c20a59
 SHA512:
-  metadata.gz: 323f3bb4faea4a371565fecf027aa190a8b4b8232b2da1a0205fcdbccaac20decddbed540a992a4a7c19df78904483b4da3e70be408f3c432c4288357c5b37d3
-  data.tar.gz: cef071ae2cac67201d942e674905dfb266cf9054bf80f3d1aed43ce9e2e032a71325101406ce689592c757335a8f2471ce14f8102f4e178b37e6dd9777c12b40
+  metadata.gz: 1377c4ecd45ba6af86ac084cddcaa444d02055606c4296633edf333f3f67c630d4dbf3283b18eed57a054ef6c017b6aa86424cbe9c0da0de60fe56809a874ca2
+  data.tar.gz: 18257e8bbfae77001b6e94eca09f63615cfcf78169eb98d75fef94bcb8027b90948a44af43389de2e6dd2c0e17ddc70b1b0314df78f487b442bde0fc8b58ede0

data/CHANGELOG

@@ -1,3 +1,81 @@
+=== 4.10.0 (2014-05-01)
+
+* Make Model.include API same as Module.include (ged) (#803)
+
+* Dataset::PlaceholderLiteralizer now handles DelayedEvaluations correctly (jeremyevans)
+
+* Refactor type conversion in the jdbc adapter, for up to a 20% speedup (jeremyevans)
+
+* Add Dataset#with_fetch_size to jdbc adapter, for setting fetch size for JDBC ResultSets (jeremyevans)
+
+* Default to a fetch_size of 100 in the jdbc/oracle adapter, similar to the oci8-based oracle adapter (jeremyevans)
+
+* Add Database#fetch_size accessor and :fetch_size option to jdbc adapter, for setting JDBC Statement fetch size (jeremyevans)
+
+* Automatically determine array type in pg_array_associations plugin, explicitly cast arrays in more places (jeremyevans, maccman) (#800)
+
+* Speed up Dataset#literal for symbols 60% by caching results, speeding up dataset literalization up to 40% or more (jeremyevans)
+
+* Speed up Sequel.split_symbol 10-20x by caching results, speeding up dataset literalization up to 80% or more (jeremyevans)
+
+* Speed up dataset literalization for simple datasets by up to 100% (jeremyevans)
+
+* Support :fractional_seconds Database option on MySQL 5.6.5+ to support fractional seconds by default (jeremyevans) (#797)
+
+* Work around MySQL 5.6+ bug when combining DROP FOREIGN KEY and DROP INDEX in same ALTER TABLE statement (jeremyevans)
+
+* Make auto_validations plugin handle models that select from subqueries (jeremyevans)
+
+* Recognize additional disconnect errors in the postgres adapter (jeremyevans)
+
+* Make import/multi_insert insert multiple rows in a single query using a UNION on Oracle, DB2, and Firebird (jeremyevans)
+
+* Speed up association_pks many_to_many setter method by using Dataset#import (jeremyevans)
+
+* Add Model.prepared_finder, similar to .finder but using a prepared statement (jeremyevans)
+
+* Model.def_{add_method,association_dataset_methods,remove_methods} are now deprecated (jeremyevans)
+
+* Model.eager_loading_dataset and Model.apply_association_dataset_opts are now deprecated (jeremyevans)
+
+* Make prepared_statement_associations plugin handle one_through_one and one_through_many associations (jeremyevans)
+
+* Use placeholder literalizer for regular association loading for up to 85% speedup (jeremyevans)
+
+* Use placeholder literalizer for eager association loading for up to 20% speedup (jeremyevans)
+
+* Make Model#marshallable! work correctly when using the tactical_eager_loading plugin (jeremyevans)
+
+* Respect :foreign_key_constraint_name option when adding columns to existing table on MySQL (noah256) (#795)
+
+* AssociationReflection#association_dataset now handles joining tables if necessary (jeremyevans)
+
+* Support drop_view :if_exists option on SQLite, MySQL, H2, and HSQLDB (jeremyevans) (#793)
+
+* Support drop_table :if_exists option on HSQLDB (jeremyevans)
+
+* Add Database#transaction :auto_savepoint option, for automatically using a savepoint in nested transactions (jeremyevans)
+
+* Add :server_version Database option on Microsoft SQL Server, instead of querying the database for it (jeremyevans)
+
+* Support :correlated_subquery as an eager_graph and filter by associations limit strategy for one_to_* associations (jeremyevans)
+
+* Support named paramters in call_mssql_sproc on Microsoft SQL Server (y.zemlyanukhin, jeremyevans) (#792)
+
+* Handle placeholder literalizer arguments when emulating offsets (jeremyevans)
+
+* Don't attempt to emulate offsets if the dataset uses literal SQL (jeremyevans)
+
+* Use a UNION-based strategy by default to eagerly load limited associations (jeremyevans)
+
+* Support offsets without limits on MySQL, SQLite, H2, SQLAnywhere and CUBRID (jeremyevans)
+
+* Remove the install/uninstall rake tasks (jeremyevans)
+
+* Use INSERT VALUES with multiple rows for Dataset#import and #multi_insert on more databases (jeremyevans)
+
+* Support common table expressions (WITH clause) on SQLite >=3.8.3 (jeremyevans)
+
 === 4.9.0 (2014-04-01)
 
 * Recognize CHECK constraint violations on newer versions of SQLite (jeremyevans)
@@ -3298,7 +3376,7 @@
 
 * Optimize Model.[] by using static sql when possible, for a 30-40% speed increase (jeremyevans)
 
-* Add Dataset#with_sql, which returns a clone of the datatset with static SQL (jeremyevans)
+* Add Dataset#with_sql, which returns a clone of the dataset with static SQL (jeremyevans)
 
 * Refactor Dataset#literal so it doesn't need to be overridden in subadapters, for a 20-25% performance increase (jeremyevans)
 

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2013 Jeremy Evans
+Copyright (c) 2008-2014 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -34,7 +34,7 @@ If you have any comments or suggestions please post to the Google group.
 
 == Installation
 
-  sudo gem install sequel
+  gem install sequel
   
 == A Short Example
 

data/Rakefile

@@ -7,7 +7,6 @@ VERS = lambda do
   Sequel.version
 end
 CLEAN.include ["**/.*.sw?", "sequel-*.gem", ".config", "rdoc", "coverage", "www/public/*.html", "www/public/rdoc*", '**/*.rbc']
-SUDO = ENV['SUDO'] || 'sudo'
 
 # Gem Packaging and Release
 
@@ -16,16 +15,6 @@ task :package=>[:clean] do |p|
   sh %{#{FileUtils::RUBY} -S gem build sequel.gemspec}
 end
 
-desc "Install sequel gem"
-task :install=>[:package] do
-  sh %{#{SUDO} #{FileUtils::RUBY} -S gem install ./#{NAME}-#{VERS.call} --local}
-end
-
-desc "Uninstall sequel gem"
-task :uninstall=>[:clean] do
-  sh %{#{SUDO} #{FileUtils::RUBY} -S gem uninstall #{NAME}}
-end
-
 desc "Publish sequel gem to rubygems.org"
 task :release=>[:package] do
   sh %{#{FileUtils::RUBY} -S gem push ./#{NAME}-#{VERS.call}.gem}
@@ -119,7 +108,8 @@ begin
     desc "#{d} with -w, some warnings filtered"
     task "#{name}_w" do
       ENV['RUBYOPT'] ? (ENV['RUBYOPT'] += " -w") : (ENV['RUBYOPT'] = '-w')
-      sh "#{FileUtils::RUBY} -S rake #{name} 2>&1 | egrep -v \"(spec/.*: warning: (possibly )?useless use of == in void context|: warning: instance variable @.* not initialized|: warning: method redefined; discarding old|: warning: previous definition of)|rspec\""
+      rake = ENV['RAKE'] || "#{FileUtils::RUBY} -S rake"
+      sh "#{rake} #{name} 2>&1 | egrep -v \"(spec/.*: warning: (possibly )?useless use of == in void context|: warning: instance variable @.* not initialized|: warning: method redefined; discarding old|: warning: previous definition of)|rspec\""
     end
 
     desc d

data/bin/sequel

@@ -2,6 +2,7 @@
 
 require 'rubygems'
 require 'optparse'
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
 require 'sequel'
 
 code = nil

data/doc/advanced_associations.rdoc

@@ -255,22 +255,36 @@ a LIMIT:
 === Eager Loading via eager
 
 However, if you want to eagerly load an association, you must use a different
-approach.  Sequel has 3 separate strategies for dealing with such cases,
-depending on database support.
+approach.  Sequel has 4 separate strategies for dealing with such cases.
 
-On PostgreSQL, for *_one associations that don't use an offset, it will by
-default use the distinct on strategy, which uses a DISTINCT ON clause:
+The default strategy used on all databases is a UNION-based approach, which
+will submit multiple subqueries in a UNION query:
 
-  Artist.one_to_one :first_album, :class=>:Album, :order=>:release_date
+  Artist.where(:id=>[1,2]).eager(:first_10_albums).all
+  # SELECT * FROM (SELECT * FROM albums WHERE (artist_id = 1) LIMIT 10) UNION ALL
+  # SELECT * FROM (SELECT * FROM albums WHERE (artist_id = 2) LIMIT 10)
+
+This is the fastest way to load the associated objects on most databases, as long as
+there is an index on albums.artist_id.  Without an index it is probably the slowest
+approach, so make sure you have an index on the key columns.  If you cannot add an
+index, you'll want to manually specify the :eager_limit_strategy option as shown below.
+
+On PostgreSQL, for *_one associations that don't use an offset, you can
+choose to use a the distinct on strategy:
+
+  Artist.one_to_one :first_album, :class=>:Album, :order=>:release_date,
+    :eager_limit_strategy=>:distinct_on
   Artist.where(:id=>[1,2]).eager(:first_album).all
   # SELECT DISTINCT ON (albums.artist_id) *
   # FROM albums
   # WHERE (albums.artist_id IN (1, 2))
   # ORDER BY albums.artist_id, release_date
   
-Otherwise, if the database supports window functions, it will use a subquery
-with a window function:
+Otherwise, if the database supports window functions, you can choose to use
+the window function strategy:
 
+  Artist.one_to_many :first_10_albums, :class=>:Album, :order=>:release_date, :limit=>10,
+    :eager_limit_strategy=>:window_function
   Artist.where(:id=>[1,2]).eager(:first_10_albums).all
   # SELECT * FROM (
   #   SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY release_date) AS x_sequel_row_number_x
@@ -279,20 +293,21 @@ with a window function:
   # ) AS t1
   # WHERE (x_sequel_row_number_x <= 10)
   
-If the database doesn't support window functions, it will fall back to
+Alternatively, you can use the :ruby strategy, which will fall back to
 retrieving all records, and then will slice the resulting array to get
 the first 10 after retrieval.
 
 === Eager Loading via eager_graph_with_options
 
 When eager loading an association via eager_graph (which uses JOINs), the
-situation is similar.  Sequel can use a variant of the same 3 strategies,
-but by default it retrieves all records and then does the array slice
-in ruby.  As eager_graph does not support options, to use an eager_graph
-limit strategy you have to use the eager_graph_with_options method with
-the :limit_strategy option.
-
-The distinct on strategy uses DISTINCT ON in a subquery and JOINs that
+situation is similar.  While the UNION-based strategy cannot be used as
+you don't know the records being eagerly loaded in advance, Sequel can use
+a variant of the other 3 strategies.  By default it retrieves all records
+and then does the array slice in ruby.  As eager_graph does not support
+options, to use an eager_graph limit strategy you have to use the
+eager_graph_with_options method with the :limit_strategy option.
+
+The :distinct_on strategy uses DISTINCT ON in a subquery and JOINs that
 subquery:
 
   Artist.eager_graph_with_options(:first_album, :limit_strategy=>true).all
@@ -306,7 +321,7 @@ subquery:
   #   ORDER BY albums.artist_id, release_date
   # ) AS first_album ON (first_album.artist_id = artists.id)
 
-The window function approach JOINs to a nested subquery using a window
+The :window_function approach JOINs to a nested subquery using a window
 function:
 
   Artist.eager_graph_with_options(:first_10_albums, :limit_strategy=>true).all
@@ -322,8 +337,30 @@ function:
   #   ) AS t1 WHERE (x_sequel_row_number_x <= 10)
   # ) AS first_10_albums ON (first_10_albums.artist_id = artists.id)
 
-The reason that Sequel does not automatically use the distinct on or
-window function strategy for eager_graph is that it can perform much worse than the
+The :correlated_subquery approach JOINs to a nested subquery using a correlated
+subquery:
+
+  Artist.eager_graph_with_options(:first_10_albums, :limit_strategy=>true).all
+  # SELECT artists.id, artists.name, first_10_albums.id AS first_10_albums_id,
+  #        first_10_albums.name AS first_10_albums_name, first_10_albums.artist_id,
+  #        first_10_albums.release_date
+  # FROM artists 
+  # LEFT OUTER JOIN (
+  #   SELECT *
+  #   FROM albums
+  #   WHERE albums.id IN (
+  #     SELECT t1.id
+  #     FROM tracks AS t1
+  #     WHERE (t1.album_id = tracks.album_id)
+  #     ORDER BY release_date
+  #     LIMIT 10
+  #   )
+  # ) AS first_10_albums ON (first_10_albums.artist_id = artists.id)
+
+(SELECT * FROM tracks WHERE (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) LIMIT 1)))
+
+The reason that Sequel does not automatically use the :distinct_on, :window function
+or :correlated_subquery strategy for eager_graph is that it can perform much worse than the
 default of just doing the array slicing in ruby.  If you are only using eager_graph to
 return a few records, it may be cheaper to get all of their associated records and filter
 them in ruby as opposed to computing the set of limited associated records for all rows.
@@ -334,10 +371,14 @@ it against the default behavior and found it is faster for your use case.
 === Filtering By Associations
 
 In order to return correct results, Sequel automatically uses a limit strategy when
-using filtering by associations with limited associations, using a similar approach as
-when using eager to eagerly load.
+using filtering by associations with limited associations, if the database supports
+it.  As in the eager_graph case, the UNION-based strategy doesn't work.  Unlike
+in the eager and eager_graph cases, the array slicing in ruby approach does not work,
+you must use an SQL-based strategy.  Sequel will select an appropriate default
+strategy based on the database you are using, and you can override it using the
+:filter_limit_strategy option.
 
-The distinct on strategy:
+The :distinct_on strategy:
 
   Artist.where(:first_album=>Album[1]).all
   # SELECT *
@@ -351,7 +392,7 @@ The distinct on strategy:
   #     ORDER BY albums.artist_id, release_date
   #   )) AND (albums.id = 1))))
 
-The window function strategy:
+The :window_function strategy:
 
   Artist.where(:first_10_albums=>Album[1]).all
   # SELECT *
@@ -367,9 +408,25 @@ The window function strategy:
   #     WHERE (x_sequel_row_number_x <= 10)
   #   )) AND (albums.id = 1))))
 
-Note that if the database does not support window functions, filtering by associations
-with limited associations will not work correctly, leading it to return results where
-associated object used as an argument is not within the limit of the association.
+The :correlated_subquery strategy:
+
+  Artist.where(:first_10_albums=>Album[1]).all
+  # SELECT *
+  # FROM artists
+  # WHERE (artists.id IN (
+  #   SELECT albums.artist_id
+  #   FROM albums
+  #   WHERE ((albums.artist_id IS NOT NULL) AND (albums.id IN (
+  #     SELECT t1.id
+  #     FROM albums AS t1
+  #     WHERE (t1.artist_id = albums.artist_id)
+  #     ORDER BY release_date
+  #     LIMIT 1
+  #   )) AND (albums.id = 1))))
+
+Note that filtering by limited associations does not work on MySQL, as does not support
+any of the strategies.  It's also not supported when using composite keys on databases
+that don't support window functions and don't support multiple columns in IN.
 
 == Additional Association Types
 

data/doc/association_basics.rdoc

@@ -1732,33 +1732,32 @@ can't use LIMIT directly, since you want a limit for each group of
 associated records, not a LIMIT on the total number of records returned
 by the dataset.
 
-By default, if a *_to_many association uses a limit or offset, or a
-one_*_one association uses an offset or an order, Sequel will choose to use an
-eager limit strategy.  The default strategy depends on the database
-being used.  For databases which support window functions, a window
-function will be used.  Other databases will just have an ruby array
-slice done on the entire record set.
-
-For one_*_one associations without an offset or order, no strategy is used by default
-because none is needed for a true one-to-one association (since there
-is only one associated record per current record).  However, if you are
-using a one_to_one association where the relationship is really one_to_many,
-and using an order to pick the first matching row, then if you don't
-use an limit strategy, you'll be loading all related
-rows just to have Sequel ignore all rows after the first.  By using a
-strategy to change the query to only return one associated record per
-current record, you can get much better database performance.
-
 In general, Sequel picks an appropriate strategy, so it is not usually
-necessary to specify a specific strategy.
-
-You can specify true for this option to have Sequel choose which strategy
-to use (this is the default).  You can specify a symbol to manually choose
-a strategy.  The available strategies are:
+necessary to specify a strategy.  You can specify true for this option to
+have Sequel choose which strategy to use (this is the default).  You can
+specify a symbol to manually choose a strategy.  The available strategies are:
 
+:union :: Uses one or more UNION queries with a subquery for each record
+          you are eagerly loading for (this is the default strategy).
 :distinct_on :: Uses DISTINCT ON to ensure only the first matching record
                 is loaded (only used for one_*_one associations without
                 offsets on PostgreSQL).
 :window_function :: Uses a ROW_NUMBER window functions to ensure the
                     correctly limited/offset records are returned.
 :ruby :: Uses ruby array slicing to emulate database limiting/offsetting.
+
+==== :subqueries_per_union
+
+The number of subqueries per union query to use when eager loading for a
+limited association using a union strategy.  This defaults to 40, but the
+optimum number depends on the database in use and the latency between the
+database and the application.
+
+==== :filter_limit_strategy
+
+The strategy to use when filtering by limited associations.  In general
+Sequel will choose either a :distinct_on, :window_function, or
+:correlated_subquery strategy based on the association type and what
+the database supports, but you can override that if necessary using
+this option.
+

data/doc/core_extensions.rdoc

@@ -170,7 +170,7 @@ Alternative: Sequel.like:
 
   Sequel.like(:a, 'b%')
 
-==== like
+==== ilike
 
 Symbol#ilike returns a case insensitive LIKE expression between the identifier and the given argument:
 

data/doc/opening_databases.rdoc

@@ -304,6 +304,10 @@ The following additional options are supported:
 :config_default_group :: The default group to read from the in the MySQL config file.
 :config_local_infile :: If provided, sets the Mysql::OPT_LOCAL_INFILE option on the connection with the given value.
 :encoding :: Specify the encoding/character set to use for the connection.
+:fractional_seconds :: On MySQL 5.6.5+, this option is recognized and will include fractional seconds in
+                       time/timestamp values, as well as have the schema method create columns that can contain
+                       fractional seconds by deafult.  This option is also supported on other adapters that connect
+                       to MySQL.
 :socket :: Can be used to specify a Unix socket file to connect to instead of a TCP host and port.
 :sql_mode :: Set the sql_mode(s) for a given connection.  Can be single symbol or string,
              or an array of symbols or strings (e.g. <tt>:sql_mode=>[:no_zero_date, :pipes_as_concat]</tt>).
@@ -444,6 +448,9 @@ options that you may want to set are :login_timeout, :timeout, :tds_version, :az
 
 Other Sequel specific options:
 
+:server_version :: Override the server version to use (9000000 = SQL Server 2005).
+                   This also works on any other adapter that connects to Microsoft
+                   SQL Server.
 :textsize :: Override the default TEXTSIZE setting for this connection.  The FreeTDS
              default is small (around 64000 bytes), but can be set up to around 2GB.
              This should be specified as an integer.  If you plan on setting large

data/doc/release_notes/4.10.0.txt

@@ -0,0 +1,226 @@
+= Performance Enhancements
+
+* Dataset literalization for simple datasets is now faster by
+  creating a per-adapter SQL literalization method instead of
+  having all adapters share a generic method with higher overhead.
+  Sequel.split_symbol now caches results globally. Symbol
+  literalization is now cached per Database.
+
+  Combining these three optimizations, here are the performance
+  increases compared to 4.9.0 for a couple example datasets:
+
+    ds1 = DB[:a]
+    ds2 = DB[:a].select(:a, :b).where(:c=>1).order(:d, :e)
+
+            .sql     .all (1 row)
+    ds1     140%     11%
+    ds2     187%     32%
+
+* Regular association loading now uses a placeholder literalizer
+  in most cases, for up to an 85% improvement when loading
+  simple associations.
+
+* Eager loading associations using Dataset#eager now uses a
+  placeholder literalizer in most cases, for up to a
+  20% improvement when eager loading simple associations.
+
+* Eager loading associations with limits using Dataset#eager now
+  uses a UNION-based strategy by default.  After extensive
+  testing, this was found to be the fastest strategy if the
+  key columns are indexed.  Unfortunately, it is a much slower
+  strategy if the key columns are not indexed.  You can override
+  the default UNION strategy by using the :eager_limit_strategy
+  association option.
+
+  On some databases, execution time of UNION queries with n subqueries
+  increases faster than O(n).  Also, there are limits on the number of
+  subqueries supported in a single UNION query.  Sequel chooses a
+  default limit of 40 subqueries per UNION query.  You can increase
+  this via the :subqueries_per_union association option.
+
+* Dataset#import and #multi_insert can now insert multiple rows
+  in a single query on H2, HSQLDB, Derby, SQLAnywhere, CUBRID,
+  SQLite, Oracle, DB2, and Firebird, which should be significantly
+  faster than previous versions that issued a separate INSERT query
+  per row.
+
+* The many_to_many setter method in the association_pks plugin now
+  uses Dataset#import to insert many rows at once, instead of using
+  a seperate query per insert.
+
+* The jdbc adapter's type conversion has been rewritten to be
+  more similar to the other adapters, setting up the type
+  conversion procs before iterating over results.  This increases
+  performance up to 20%.
+
+* The jdbc/oracle adapter now defaults to a fetch_size of 100,
+  similar to the oci8-based oracle adapter, significantly improving
+  performance for large datasets.
+
+= New Features
+
+* Database#transaction now supports an :auto_savepoint option.  This
+  option makes it so that transactions inside the transaction block
+  automatically use savepoints unless they use the :savepoint=>false
+  option.  This should make testing transactional behavior easier.
+
+* Model.prepared_finder has been added.  This has an API similar to
+  Model.finder, but it uses a prepared statement instead of a
+  placeholder literalizer.  It is less flexible than Model.finder
+  as prepared statements have fixed SQL, but it may perform better.
+
+* Common table expressions (WITH clauses) are now supported on SQLite
+  3.8.3+.
+
+* :correlated_subquery has been added as an eager_graph and filter by
+  association limit strategy for one_to_one and one_to_many
+  associations.  In certain cases it was found that this is faster
+  than the :window_function limit strategy.  It is the default
+  filter by associations limit strategy on databases that do not
+  support window functions.
+
+  Filtering by limited associations using a correlated subquery
+  strategy does not work in all cases, but it should handle most
+  cases correctly.
+
+* The prepared_statement_associations plugin now handles
+  one_through_one and one_through_many associations.
+
+* Sequel now emulates support for offsets without limits on MySQL,
+  SQLite, H2, SQLAnywhere, and CUBRID.
+
+* In the jdbc adapter, the Database#fetch_size accessor and
+  :fetch_size option can be used to automatically set the JDBC
+  fetch size for JDBC Statement objects created by the database.
+
+* Dataset#with_fetch_size has been added to jdbc adapter datasets,
+  setting the fetch size to use on ResultSets generated by the
+  dataset.  This generally has the effect of overriding the
+  Database fetch_size setting.
+ 
+* On MySQL 5.6.5+, Sequel supports a :fractional_seconds Database
+  option, which will use fractional seconds for timestamp values,
+  and have the schema modification code create timestamp columns
+  that accept fractional timestamps by default.
+
+* Database#call_mssql_sproc on Microsoft SQL Server now handles named
+  parameters:
+
+    DB.call_mssql_sproc(:sproc_name, :args => {
+      'input_arg1_name' => 'input arg1 value',
+      'input_arg2_name' => 'input arg2 value',
+      'output_arg_name' => [:output, 'int', 'result key name']
+    })
+
+* Database#drop_view now supports an :if_exists option on SQLite,
+  MySQL, H2, and HSQLDB.
+
+* Database#drop_table now supports an :if_exists option on HSQLDB.
+
+* A :filter_limit_strategy association option has been added, for
+  choosing the strategy that will be used when filtering/excluding by
+  associations with limits.  For backwards compatibility, Sequel will
+  fallback to looking at the :eager_limit_strategy option.
+
+* A :server_version Database option is now supported on Microsoft SQL
+  Server, which will use the value given instead of querying for it.
+
+= Other Improvements
+
+* Dataset::PlaceholderLiteralizer arguments are how handled
+  correctly when emulating offsets via the row_number window function
+  on DB2, MSSQL <=2012, and Oracle.
+
+* Dataset::PlaceholderLiteralizer now handles DelayedEvaluation
+  objects correctly.
+
+* Offset emulation is skipped if static SQL is used on Access,
+  DB2, and MSSQL <=2008.
+
+* Additional disconnect errors are now recognized in the postgres
+  adapter.
+
+* The :foreign_key_constraint_name option is now respected when
+  adding a foreign key column to an existing table on MySQL.
+
+* Sequel now attempts to work around a bug on MySQL 5.6+ when
+  combining DROP FOREIGN KEY and DROP INDEX in the same ALTER TABLE
+  statement.
+
+* Dataset#for_update is now respected on H2.
+
+* Timestamp with local time zone types are now returned as
+  Time/DateTime objects on jdbc/oracle.
+
+* Model.include now has the same API as Module.include.
+
+* Model#marshallable! now works correctly when using the
+  tactical_eager_loading plugin.
+
+* The pg_array_associations plugin now attempts to automatically
+  determine the correct array type to use, and explicitly casts
+  to that array type in more places.
+
+* The auto_validations plugin now handles models that select from
+  subqueries.
+
+* The association_pks plugin does no longer creates getter and setter
+  methods for one_through_one associations.
+
+* bin/sequel now uses the Sequel code in the related lib directory.
+  This makes it easier to use from a repository checkout.
+
+= Backwards Compatibility
+
+* AssociationReflection#associated_dataset now returns a joined
+  dataset for associations that require joins (e.g. many_to_many).
+  Anyone using this directly for associations that require joins
+  probably needs to update their code.
+
+* Model.associate now adds the association instance methods instead
+  of relying on the def_#{association_type} method doing so.  Anyone
+  using custom association types probably needs to update their code.
+
+* Model.eager_loading_dataset, .apply_association_dataset_opts, and
+  .def_{add_method,association_dataset_methods,remove_methods}
+  are now deprecated.
+
+* Key conditions for associations requiring joins have been moved
+  from the JOIN ON clause to the WHERE clause.  This should be
+  optimized the same by the database, but it can break tests that
+  expect specific SQL.
+
+* Dataset#_insert_sql and #_update_sql are now private instead of
+  protected.
+
+* The install/uninstall rake tasks have been removed.
+
+* Model association and association reflection internals have
+  changed significantly, if you were relying on them, you'll
+  probably need to update your code.
+
+* Database transaction internals have changed significantly, if you
+  were relying on them, you'll probably need to update your code.
+
+* Dataset literalization internals have changed significantly, with
+  the Dataset#*_clause_methods private methods being removed.
+  Custom adapters that used these methods should switch to using the
+  new Dataset.def_sql_method method.
+
+* Common table expressions are no longer enabled by default in
+  Sequel.  External adapters for databases that support common
+  table expressions should define Dataset#supports_cte?(type) to
+  return true.
+
+* Support for RETURNING is no longer determined via introspection.
+  External adapters for databases that support RETURNING should
+  define Dataset#supports_returning?(type) to return true.
+
+* The new jdbc adapter type conversion code may not be completely
+  compatible with the previous code.  The currently known case
+  where it is different is on jdbc/postgresql, when using an
+  array type where no conversion proc exists, the returned object
+  will be a ruby array containing java objects, instead of a ruby
+  array containing ruby objects.  It is recommended that
+  jdbc/postgresql users using array types use the pg_array extension
+  to avoid this issue.