sequel 4.41.0 → 4.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '04857dbc303fa5d8cd9cb242dee35021eada5410'
-  data.tar.gz: f05247db19fc6bfb7afdb6730d301eed82fd398e
+  metadata.gz: 950d9818b7e057e8728dde0e8bc5460dc3a91679
+  data.tar.gz: e0cec40c01a7eeb1a6ca8d6d993155a74b032f9d
 SHA512:
-  metadata.gz: 320e1e83b8f39e3baa396ec77fefd70f780cd96960c5e86353419d3f2f905f4fbdfc3acf18bb1e37c35620e5dca9d2401a7895b77a205ccf52d31dd8d25b07b6
-  data.tar.gz: f1ea15ae50f0b4e398966a5fbedde61f943032a157406e6e4d39fdc01dbcae4dc3b97432395267ae82b848af251f39ece08cf20f65893258f636d9397483fb70
+  metadata.gz: e0bda9bf194bd56954f1647775b8de2d6ed2ace58691c32cf58f2d11717980492dbd0f2dad3f4a13ee2cc45eaa033e2b18456b556b9166a24163e1f7eb8fd41d
+  data.tar.gz: 5c8f48cee321a25826ac480fa09c82289f105d5ff793fee90a58c47f9b91ae4daf2ccd0dbd516391c45fff54ee3036726a9cb0fd22a7d832d77a86e98ddd866f

data/CHANGELOG

@@ -1,3 +1,101 @@
+=== 4.42.0 (2017-01-01)
+
+* Handle eager load callbacks correctly for one_to_one associations with orders or offsets when window functions are not supported (jeremyevans)
+
+* Raise Sequel::Error if using an :eager_limit dataset option when eager loading a singular association (jeremyevans)
+
+* Replace internal uses of Dataset#select_more with #select_append to save a method call (jeremyevans)
+
+* Make Dataset#order_append the primary method, and #order_more the alias, for similarity to #select_append and #select_more (jeremyevans)
+
+* Replace internal uses of Dataset#filter with #where to save a method call (jeremyevans)
+
+* Do not set :auto_increment in the schema information for integer columns that are part of a composite primary key on SQLite (jeremyevans)
+
+* Use autoincrement setting on integer primary key columns when emulating table modification methods on SQLite (thenrio, jeremyevans) (#1277, #1278)
+
+* Make the pagination extension work on frozen datasets (jeremyevans)
+
+* Make Dataset#server work for frozen model datasets using the sharding plugin (jeremyevans)
+
+* Make Dataset#nullify in the null_dataset extension work on frozen datasets (jeremyevans)
+
+* Make Model#set_server work when using a frozen model dataset (jeremyevans)
+
+* Make Dataset#ungraphed work on a frozen model dataset (jeremyevans)
+
+* Add Dataset#with_{autoid,fetch,numrows} to the mock adapter, returning cloned datasets with the setting changed (jeremyevans)
+
+* Make looser_typecasting extension handle the strict BigDecimal parsing introduced in ruby 2.4rc1 (jeremyevans)
+
+* Make Database#{db,opts}= in the sequel_3_dataset_methods extension raise for frozen datasets (jeremyevans)
+
+* Speed up repeated calls to Dataset#{interval,range} for frozen datasets using a cached placeholder literalizer (jeremyevans)
+
+* Speed up repeated calls to Dataset#get with a single argument for frozen datasets using a cached placeholder literalizer (jeremyevans)
+
+* Speed up repeated calls to Dataset#{first,last} with arguments/blocks for frozen datasets using a cached placeholder literalizer (jeremyevans)
+
+* Speed up repeated calls to Dataset#{avg,min,max,sum} for frozen datasets using a cached placeholder literalizer (jeremyevans)
+
+* Cache dataset returned by Dataset#skip_locked for frozen datasets (jeremyevans)
+
+* Cache dataset returned by Dataset#for_update for frozen datasets (jeremyevans)
+
+* Cache dataset returned by Dataset#un{filtered,grouped,limited,ordered} for frozen datasets (jeremyevans)
+
+* Cache dataset returned by Dataset#reverse (no args) for frozen datasets (jeremyevans)
+
+* Cache dataset returned by Dataset#invert for frozen datasets (jeremyevans)
+
+* Speed up repeated calls to Dataset#count with an argument or block for frozen datasets using a cached placeholder literalizer (jeremyevans)
+
+* Using :on_duplicate_columns=>:warn Database option with duplicate_columns_handler now prepends file/line to the warning message (jeremyevans)
+
+* Move identifier mangling code to identifier_mangling extension, load by default unless using :identifier_mangling=>false Database option (jeremyevans)
+
+* Allow Dataset#with_extend to accept a block and create a module with that block that the object is extended with (jeremyevans)
+
+* Speed up repeated calls to with_pk on the same frozen model dataset using a cached placeholder literalizer (jeremyevans)
+
+* Add dataset_module methods such as select and order that define dataset methods which support caching for frozen datasets (jeremyevans)
+
+* Cache subset datasets if they don't use blocks or procs for frozen model datasets (jeremyevans)
+
+* Cache intermediate dataset used in Dataset#{last,paged_each} for frozen model datasets without an order (jeremyevans)
+
+* Cache dataset returned by Dataset#naked for frozen datasets (jeremyevans)
+
+* Cache intermediate dataset used in Dataset#last (no args) for frozen datasets (jeremyevans)
+
+* Cache intermediate dataset used in Dataset#first (no args) and #single_record for frozen datasets (jeremyevans)
+
+* Cache intermediate dataset used in Dataset#empty? for frozen datasets (jeremyevans)
+
+* Cache intermediate dataset used in Dataset#count (no args) for frozen datasets (jeremyevans)
+
+* Warn if :conditions option may be unexpectedly ignored during eager_graph/association_join (jeremyevans) (#1272)
+
+* Cache SELECT and DELETE SQL for most frozen datasets (jeremyevans)
+
+* Freeze most SQL::Expression objects and internal state by default (jeremyevans)
+
+* Freeze Dataset::PlaceholderLiteralizer and Dataset::PlaceholderLiteralizer::Argument instances (jeremyevans)
+
+* Freeze most dataset opts values to avoid unintentional modification (jeremyevans)
+
+* Add Dataset#with_convert_smallint_to_bool on DB2, returning a clone with convert_smallint_to_bool set (jeremyevans)
+
+* Make Dataset#freeze actually freeze the dataset on ruby 2.4+ (jeremyevans)
+
+* Avoid using instance variables other than @opts for dataset data storage (jeremyevans)
+
+* Add freeze_datasets extension, making all datasets for a given Database frozen (jeremyevans)
+
+* Refactor prepared statement internals, using opts instead of instance variables (jeremyevans)
+
+* Model.set_dataset now operates on a clone of the dataset given instead of modifying it, so it works with frozen datasets (jeremyevans)
+
 === 4.41.0 (2016-12-01)
 
 * Add Dataset#with_mssql_unicode_strings on Microsoft SQL Server, returning a clone with mssql_unicode_strings set (jeremyevans)

data/README.rdoc

@@ -83,7 +83,7 @@ Sequel uses the concept of datasets to retrieve data. A Dataset object encapsula
 
 For example, the following one-liner returns the average GDP for countries in the middle east region:
 
-  DB[:countries].filter(:region => 'Middle East').avg(:GDP)
+  DB[:countries].where(:region => 'Middle East').avg(:GDP)
   
 Which is equivalent to:
 
@@ -91,7 +91,7 @@ Which is equivalent to:
 
 Since datasets retrieve records only when needed, they can be stored and later reused. Records are fetched as hashes (or custom model objects), and are accessed using an +Enumerable+ interface:
 
-  middle_east = DB[:countries].filter(:region => 'Middle East')
+  middle_east = DB[:countries].where(:region => 'Middle East')
   middle_east.order(:name).each{|r| puts r[:name]}
   
 Sequel also offers convenience methods for extracting data from Datasets, such as an extended +map+ method:
@@ -404,7 +404,7 @@ and not raise an exception outside the block, you can raise the
 
   DB.transaction do
     posts.insert(:category => 'ruby', :author => 'david')
-    if posts.filter('stamp < ?', Date.today - 7).update(:state => 'archived') == 0
+    if posts.where('stamp < ?', Date.today - 7).update(:state => 'archived') == 0
       raise Sequel::Rollback
     end
   end
@@ -791,27 +791,40 @@ The recommended way to implement table-wide logic by defining methods on the dat
 
   class Post < Sequel::Model
     dataset_module do
-      def posts_with_few_comments
+      def with_few_comments
         where{num_comments < 30}
       end
 
-      def clean_posts_with_few_comments
-        posts_with_few_comments.delete
+      def clean_boring
+        with_few_comments.delete
       end
     end
   end
 
 This allows you to have access to your model API from filtered datasets as well:
 
-  Post.where(:category => 'ruby').clean_posts_with_few_comments
+  Post.where(:category => 'ruby').clean_boring
+  # DELETE FROM posts WHERE ((category = 'ruby') AND (num_comments < 30))
 
-Sequel models also provide a +subset+ class method that creates a dataset method with a simple filter:
+Inside +dataset_module+ blocks, there are numerous methods that support easy creation of dataset methods.
+Most of these methods are named after the dataset methods themselves, such as +select+, +order+, and
++group+, and there is also a method named +subset+ which uses a filter:
 
   class Post < Sequel::Model
-    subset(:posts_with_few_comments){num_comments < 30}
-    subset :invisible, Sequel.~(:visible)
+    dataset_module do
+      subset(:with_few_comments){num_comments < 30}
+      select :with_title_and_date, :id, :title, :post_date
+      order :by_post_date, :post_date
+      limit :top10, 10
+    end
   end
 
+  Post.with_few_comments.with_title_and_date.by_post_date.top10
+  # SELECT id, title, post_date
+  # FROM posts
+  # ORDER BY post_date
+  # LIMIT 10
+
 === Model Validations
 
 You can define a +validate+ method for your model, which +save+

data/doc/active_record.rdoc

@@ -195,7 +195,7 @@ Sequel keeps datasets in an abstract format, allowing for powerful capabilities.
 
 This isn't possible when you use an SQL string fragment.  Another case where using an SQL string fragment hurts you is when the SQL syntax cannot handle all cases:
 
-  Album.filter('id NOT IN ?', ids_array)
+  Album.where('id NOT IN ?', ids_array)
 
 That will work fine if +ids_array+ is not empty, but will not work correctly if it is empty.  With Sequel, you do:
 
@@ -205,11 +205,11 @@ That will handle cases where +ids_array+ is empty correctly.
 
 A third reason to not use SQL string fragments is database independence.  For example, if you want a case insensitive search that works on both PostgreSQL and MySQL, the following won't work:
 
-  Album.filter('name LIKE ?', 'A%')
+  Album.where('name LIKE ?', 'A%')
 
 This is because LIKE is case sensitive on PostgreSQL, but case insensitive on MySQL.  With Sequel, you would do:
 
-  Album.filter(Sequel.ilike(:name, 'A%'))
+  Album.where(Sequel.ilike(:name, 'A%'))
 
 This will do a case insensitive search on both databases.  If you want a case sensitive search on both, you can use +like+ instead of +ilike+.
 
@@ -569,7 +569,7 @@ If you are using <tt>find(:last, ...)</tt>, you need to specify an order in Sequ
 
   Album.where(:artist_id=>1).order(:name).last
   # You could also do:
-  Album.where(:artist_id=>1).reverse_order(:name).first
+  Album.where(:artist_id=>1).reverse(:name).first
 
 If you are using <tt>find(:all, ...)</tt>, you use a method chain instead of passing the options, and end it with +all+:
 

data/doc/advanced_associations.rdoc

@@ -700,9 +700,9 @@ You can easily get a node's parent with node.parent, and a node's children with
 node.children.  You can even eager load the relationship up to a certain depth:
 
   # Eager load three generations of generations of children for a given node 
-  Node.filter(:id=>1).eager(:children=>{:children=>:children}).all.first
+  Node.where(:id=>1).eager(:children=>{:children=>:children}).all.first
   # Load parents and grandparents for a group of nodes
-  Node.filter{id < 10}.eager(:parent=>:parent).all
+  Node.where{id < 10}.eager(:parent=>:parent).all
 
 What if you want to get all ancestors up to the root node, or all descendents,
 without knowing the depth of the tree?

data/doc/association_basics.rdoc

@@ -16,7 +16,7 @@ database tables.  Without associations, if you had classes such as:
 And you wanted to get all of the albums for a given artist (assuming each
 album was associated with only one artist):
 
-  Album.filter(:artist_id=>@artist.id).all
+  Album.where(:artist_id=>@artist.id).all
   
 Or maybe you want to add an album for a given artist:
 
@@ -962,7 +962,10 @@ In both cases an array of symbols can be used for a composite key association:
 
 The conditions to use to filter the association, can be any argument passed to +where+.
 If you use a hash or an array of two element arrays, this will also be used as a
-filter when using eager_graph to load the association.
+filter when using eager_graph or association_join to load the association.  If you
+do not use a hash or array of two element arrays, consider also using the :graph_block
+option to specifying a similar condition if you plan to use this association with
+eager_graph or association_join.
 
   Artist.one_to_many :good_albums, :class=>:Album, :conditions=>{:good=>true}
   @artist.good_albums

data/doc/cheat_sheet.rdoc

@@ -113,9 +113,9 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 
 == Ordering
 
-  dataset.order(:kind)
-  dataset.reverse_order(:kind)
-  dataset.order(Sequel.desc(:kind), :name)
+  dataset.order(:kind) # kind
+  dataset.reverse(:kind) # kind DESC
+  dataset.order(Sequel.desc(:kind), :name) # kind DESC, name
 
 == Limit/Offset
 

data/doc/core_extensions.rdoc

@@ -332,8 +332,8 @@ Alternative: Sequel.or:
 
 Array#sql_value_list wraps the array in an array subclass, which Sequel will always treat as a value list and not a conditions specifier.  By default, Sequel treats arrays of two element arrays as a conditions specifier.
 
-  DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
-  DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
+  DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
+  DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
 
 Alternative: Sequel.value_list:
 

data/doc/dataset_basics.rdoc

@@ -48,7 +48,7 @@ Thread safety you don't really need to worry about, but chainability is core to
 Another important thing to realize is that dataset methods that return modified datasets do not execute the dataset's code on the database.  Only dataset methods that return or yield results will execute the code on the database:
 
   # No SQL queries sent:
-  ds3 = ds.select(:id, :name).order(:name).filter{id < 100}
+  ds3 = ds.select(:id, :name).order(:name).where{id < 100}
   
   # Until you call a method that returns results
   results = ds3.all
@@ -56,12 +56,12 @@ Another important thing to realize is that dataset methods that return modified
 One important consequence of this API style is that if you use a method chain that includes both methods that return modified copies and a method that executes the SQL, the method that executes the SQL should generally be the last method in the chain:
 
   # Good
-  ds.select(:id, :name).order(:name).filter{id < 100}.all
+  ds.select(:id, :name).order(:name).where{id < 100}.all
   
   # Bad
-  ds.all.select(:id, :name).order(:name).filter{id < 100}
+  ds.all.select(:id, :name).order(:name).where{id < 100}
   
-This is because all will return an array of hashes, and select, order, and filter are dataset methods, not array methods.
+This is because all will return an array of hashes, and +select+, +order+, and +where+ are dataset methods, not array methods.
 
 == Methods
 

data/doc/dataset_filtering.rdoc

@@ -191,7 +191,7 @@ You can concatenate SQL strings using Sequel.join:
 
 Sequel.join also takes a join argument:
 
-  items.filter(Sequel.join([:name, :comment], ':').like('John:%nice%')).sql
+  items.where(Sequel.join([:name, :comment], ':').like('John:%nice%')).sql
   #=> "SELECT * FROM items WHERE ((name || ':' || comment) LIKE 'John:%nice%' ESCAPE '\')"
 
 == Filtering using sub-queries

data/doc/migration.rdoc

@@ -437,7 +437,7 @@ artist per album to multiple artists per album:
        having{artist_id >  0}.
        all do |r|
          self[:artists].
-          filter(:id=>r[:album_id]).
+          where(:id=>r[:album_id]).
           update(:artist_id=>r[:artist_id])
        end
 
@@ -635,3 +635,21 @@ database the migration is being run on, and operate accordingly:
       end
     end
   end
+
+== Using Database Extensions in Migrations
+
+If you need to use database extensions in migrations (e.g. +:pg_enum+), you should load the extension in the up or down block as appropriate.
+
+  Sequel.migration do
+    up do
+      extension :pg_enum
+
+      # migration here
+    end
+
+    down do
+      extension :pg_enum
+
+      # migration here
+    end
+  end

data/doc/prepared_statements.rdoc

@@ -64,7 +64,7 @@ may itself contain placeholders:
 Prepared statement support is similar to bound variable support, but you
 use <tt>Dataset#prepare</tt> with a name, and <tt>Dataset#call</tt> or <tt>Database#call</tt> later with the values:
 
-  ds = DB[:items].filter(:name=>:$n)
+  ds = DB[:items].where(:name=>:$n)
   ps = ds.prepare(:select, :select_by_name)
   ps.call(:n=>'Jim')
   DB.call(:select_by_name, :n=>'Jim') # same as above
@@ -76,7 +76,7 @@ and update queries, the hash to insert/update is passed to +prepare+:
   ps1 = DB[:items].prepare(:insert, :insert_with_name, :name=>:$n)
   ps1.call(:n=>'Jim')
   DB.call(:insert_with_name, :n=>'Jim') # same as above
-  ds = DB[:items].filter(:name=>:$n)
+  ds = DB[:items].where(:name=>:$n)
   ps2 = ds.prepare(:update, :update_name, :name=>:$new_n)
   ps2.call(:n=>'Jim', :new_n=>'Bob')
   DB.call(:update_name, :n=>'Jim', :new_n=>'Bob') # same as above

data/doc/release_notes/4.42.0.txt

@@ -0,0 +1,221 @@
+= New Features
+
+* There have been numerous improvements this release related to
+  frozen datasets.  Frozen datasets now work in almost all cases,
+  except when calling a dataset mutation method.
+
+  When using ruby 2.4, Sequel uses the new support for
+  clone(:freeze=>false) to actually freeze datasets while allowing
+  them to copy singleton classes/extended modules from the dataset
+  calling clone.  On earlier versions of ruby, the dataset opts
+  are now frozen, preventing more types of accidental modification.
+
+  The dataset internals were refactored to reduce the number of
+  instance variables.  Now, datasets store all of their state
+  in opts.  Additionally, all datasets now use a thread-safe
+  cache for storing cached state such as the dataset's columns.
+  Previously, accessing/setting the columns was not thread-safe,
+  unless the ruby interpreter used thread-safe methods for
+  instance variable getting/setting.
+
+  Frozen datasets use this new cache to optimize repeated method
+  calls, resulting in substantial performance speedups.  This can
+  include caching returned and/or intermediate datasets, SELECT and
+  DELETE SQL generated, as well as internal objects designed to
+  optimize the building of SQL strings with different arguments.
+
+  Even for fairly simple datasets, this can result in up to 10x
+  performance improvements for dataset methods that don't require
+  database access, and up to 3x performance improvements for dataset
+  methods that do require database access.
+
+* A freeze_datasets Database extension has been added which
+  automatically freezes all datasets for the Database instance.
+  This also enables dataset caching when creating datasets using
+  Database#[] and #from using a single symbol, such as
+  DB[:table_name].  In addition to speeding up the methods
+  themselves, this also allows code such as:
+
+    DB[:foo].for_update.first
+
+  To run much faster by avoiding any dataset creation or SQL
+  string building after the first call.
+
+  The freeze_datasets extension makes #dup an alias of #clone,
+  ensuring that all cloned datasets that were originally created
+  by the Database instance are frozen.
+
+  It is highly recommended that you start using the
+  freeze_datasets extension in your applications using Sequel,
+  as this extension will become the default and only behavior
+  in Sequel 5.  Unfrozen datasets and dataset mutation will
+  not be supported in Sequel 5.
+
+* The dataset methods created by Model#subset and
+  Model::DatasetModule#subset now cache the returned dataset if the
+  current dataset is frozen, none of the arguments are Procs, and a
+  block is not provided.  This can result in up to a 3x performance 
+  improvement for method chains that use subsets, such as:
+
+    ModelClass.subset1.subset2.subset3.first
+
+* Model::DatasetModule has had the following methods added to it:
+  distinct, exclude, exclude_having, grep, group, group_and_count,
+  group_append, having, limit, offset, order, order_append,
+  order_prepend, select, select_all, select_append, select_group,
+  where, and server. These methods create dataset methods that
+  when called call the dataset method with the same name on the
+  receiver.  Example:
+
+    class ModelClass < Sequel::Model
+      dataset_module do
+        select :with_id_and_name, :id, :name
+        where :active, :active
+        order :by_name, :name
+      end
+    end
+
+    ModelClass.active.by_name.with_id_and_name.all
+    # SELECT id, name FROM model_classes WHERE active ORDER BY name
+    # Equivalent to:
+    ModelClass.
+      where(:active).
+      order(:name).
+      select(:id, :name).
+      all
+
+  In addition to being easier than defining the methods manually, this
+  also enables caching of the datasets in most cases, so that the
+  above method chain does not create any additional datasets after the
+  first call.
+
+* Dataset#with_extend now accepts a block and will create a module
+  with that block that will be used to extend the object, after any
+  modules given as arguments have been applied:
+
+    DB[:table].with_extend{def foo; 1 end}.foo => 1
+
+* The identifier mangling support for datasets
+  (identifier_input_method and identifier_output_method) has been
+  moved to a identifier_mangling database extension, but it is still
+  loaded by default.  You can disable the loading of this extension
+  by using the :identifier_mangling=>false Database option.  Sequel
+  5 will stop loading of this extension by default, requiring you to
+  load it manually via Database#extension if you need it.
+
+  Sequel's default remains the same as before, to convert identifiers
+  to uppercase on input and lowercase on output on databases that
+  fold unquoted identifiers to uppercase (per the SQL standard), and
+  to not mangle identifiers at all on databases that fold unquoted
+  identifiers to lowercase (MySQL, PostgreSQL, SQLite).  The
+  identifier_mangling extension just allows you to change the default
+  behavior.
+
+* On DB2, Dataset#with_convert_smallint_to_bool has been added,
+  which returns a modified dataset with the
+  convert_smallint_to_bool setting changed.  Previously,
+  chaging the smallint_to_bool setting required mutating a
+  dataset.
+
+* The mock adapter now supports Dataset#with_{autoid,fetch,numrows},
+  allowing mocking of results when using frozen datasets.
+
+= Other Improvements
+
+* Using an eager load callback when eager loading a one_to_one
+  association that uses an order or offset now works correctly
+  on databases that do not support window functions.
+
+* Dataset#== and Dataset#hash are now faster as they don't need
+  to generate SQL.  As all internal state is now stored in the
+  opts, it just considers the class, db, and opts.
+
+* The prepared statement/bound variable internals were heavily
+  refactored to be simpler and more robust, to more easily
+  support native prepared statements, and to work with frozen
+  datasets.
+
+* When emulating alter table operations on SQLite, integer
+  primary keys now use AUTOINCREMENT, since that is Sequel's
+  default when creating tables on SQLite.
+
+* On SQLite, Database#schema no longer uses :auto_increment entries
+  when the table has a composite primary key.
+
+* Most dataset opts values are now frozen to prevent accidental
+  modification and allow for thread-safe access.
+
+* SQL::Expression subclass instances are now always frozen.
+
+* Dataset::PlaceholderLiteralizer and 
+  Dataset::PlaceholderLiteralizer::Argument instances are now
+  always frozen.
+
+* Dataset#ungraphed now works on a frozen model dataset.
+
+* Model#set_server now works when the model uses a frozen dataset.
+
+* The pagination and null_dataset extensions now work on frozen
+  datasets.
+
+* Dataset#server now works for frozen model datasets when the
+  model uses the sharding plugin.
+
+* Calling eager_graph or association_join on a model dataset
+  is now deprecated if it would ignore the association's
+  :conditions option and the :graph_conditions, :graph_block,
+  or :graph_only_conditions association option is not used.
+
+* Using the :eager_limit dataset option in an eager_load
+  callback with a singular association now raises an Error.
+  Previously, the behavior was undefined.
+
+* Calling Dataset#prepare without a name argument is now
+  deprecated.  Previously, it raised an Error in the mysql, mysql2,
+  and postgres adapters, but was allowed on other adapters.
+
+* The looser_typecasting extension now handles the strict
+  BigDecimal parsing introduced in ruby 2.4.
+
+* When using the duplicate_columns_handler extension with
+  :on_duplicate_columns=>:warn, the warning message is now
+  prepend with the file and line.
+
+* Internally, Sequel uses Dataset#where instead of #filter,
+  reverse instead of reverse_order, and select_append instead
+  of select_more to save a method call and array creation.
+
+* Dataset#db= and #opts= in the sequel_3_dataset_methods
+  extension now raise a RuntimeError if the dataset is frozen.
+
+* Sequel's tests now run without warnings when using Minitest
+  5.10.
+
+* Sequel now issues a deprecation message instead of a warning
+  when used with PostgreSQL <8.2.
+
+= Backwards Compatibility
+
+* Any external dataset extensions or adapters that modified or
+  directly accessed dataset instance variables other than @db and
+  @opts (such as @columns) needs to be updated to work with the
+  new dataset internals.
+
+* Any external adapters that implemented native prepared statements/
+  bound variables need to be updated to work with the new internal
+  prepared statement API.
+
+* Model.set_dataset and .dataset= now operate on a clone of the
+  dataset given, instead of mutating the dataset that is passed in.
+  This allows them to work with frozen datasets, but can change
+  the behavior if you mutate a dataset after passing it to one
+  of these methods.  Anyone doing that needs to change their code
+  to get the current copy of the model's dataset, and mutate that,
+  or better yet, avoid mutating datasets at all.
+
+* Dataset#columns now calls #columns! instead of the other way around,
+  which may require external plugins/extensions that override #columns
+  to switch to overriding #columns!.
+
+* External adapters that want to disable identifier mangling by
+  default need to be updated.