sequel 4.39.0 → 4.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: faeae955d80275ae969500515f7a62f6db3ee1d2
-  data.tar.gz: 69e8bed296f9a6044bdbecfb29317562f2890bb8
+  metadata.gz: 7036daa139080700c287bce9f5c7c2d068d5476e
+  data.tar.gz: cd75becb35bf05f4a74b70c6468bbfbd214359e5
 SHA512:
-  metadata.gz: 6f87b9f699854635a13c664b49e0a9be073a6f1daf1dc00ccfa7c352d211939d514a39b5a057f4fd90a5f8ed7737ea8afc2f54afcbd68d0b8ca07babeed88e22
-  data.tar.gz: 9ff3136d2113273d89d4dd1552aa5ba30bea4e39edbfc4535f2762d35e6c21badfd5131e1f726be4d534b9f2f5960e498f9d7e3944e858716b7180c2a23c06ba
+  metadata.gz: 46cb6f09318eab28fa222d4e37484bb5781d1f94cbe4e341dd2c70c521819513e3f877e74a31dd90b998fa35abeea4ab1366e67a3bd883f85d8eec531f1841c3
+  data.tar.gz: 71ec283114e83204a544ccdc22fd5f73cad5cd403e6c2c17d55318a6dccbe1ae5b131d62ff9cd6a3552047f4808bc41bce1f04755d123ece61a16020aa7dffe9

data/CHANGELOG

@@ -1,3 +1,37 @@
+=== 4.40.0 (2016-10-28)
+
+* Make column_select plugin not raise an exception if the model's table does not exist (jeremyevans)
+
+* Make dataset_associations plugin correctly handle (many|one)_through_many associations with single join table (jeremyevans) (#1253)
+
+* Add s extension, with adds Sequel::S module that includes private #S method for calling Sequel.expr, including use as refinement (jeremyevans)
+
+* Add symbol_as and symbol_as_refinement extensions so that :column.as(:alias) is treated as Sequel.as(:column, :alias) (jeremyevans)
+
+* Add symbol_aref and symbol_aref_refinement extensions so that :table[:column] is treated as Sequel.qualify(:table, :column) (jeremyevans)
+
+* Add Sequel.split_symbols=, to support the disabling of splitting symbols with double/triple underscores (jeremyevans)
+
+* Make SQL::QualifiedIdentifier convert SQL::Identifier arguments to strings, fixing Sequel[:schema][:table] usage in schema methods (jeremyevans)
+
+* Do not attempt to combine non-associative operators (jeremyevans) (#1246)
+
+* Automatically add NOT NULL to columns when adding primary keys if the database doesn't handle it (jeremyevans)
+
+* Make prepared_statements plugin correctly handle lookup on joined datasets (jeremyevans) (#1244)
+
+* Make Database#tables with :qualify=>true option handle table names with double underscores correctly (jeremyevans) (#1241)
+
+* Add SQL::Identifier#[] and SQL::QualifiedIdentifier#[] for creating qualified identifiers (jeremyevans)
+
+* Add support for Dataset#insert_conflict :conflict_where option, for a predicate to use in ON CONFLICT clauses (chanks) (#1240)
+
+* Freeze Dataset::NON_SQL_OPTIONS, add private Dataset#non_sql_options, fixing thread safety issues during require (jeremyevans)
+
+* Make the callable returned by Database#rollback_checker thread safe (jeremyevans)
+
+* Make lazy_attributes and dataset_associations plugins work if insert_returning_select plugin is loaded before on model with no dataset (jeremyevans)
+
 === 4.39.0 (2016-10-01)
 
 * Make active_model plugin use rollback_checker instead of after_rollback hook (jeremyevans)

data/README.rdoc

@@ -453,14 +453,14 @@ Ruby strings are generally treated as SQL strings:
 === Qualifying identifiers (column/table names)
 
 An identifier in SQL is a name that represents a column, table, or schema.
-Identifiers can be qualified by using the double underscore special notation <tt>:table__column</tt>:
+By default, identifiers can be qualified by using the double underscore special notation <tt>:table__column</tt>:
 
   items.literal(:items__price)
   # items.price
 
-Another way to qualify columns is to use the <tt>Sequel.qualify</tt> method:
+Another way to qualify columns is to use the <tt>Sequel[][]</tt> method:
 
-  items.literal(Sequel.qualify(:items, :price))
+  items.literal(Sequel[:items][:price])
   # items.price
 
 While it is more common to qualify column identifiers with table identifiers, you can also qualify table identifiers with schema identifiers
@@ -471,7 +471,7 @@ to select from a qualified table:
 
 === Identifier aliases
 
-You can also alias identifiers by using the triple underscore special notation <tt>:column___alias</tt> or <tt>:table__column___alias</tt>:
+By default, you can also alias identifiers by using the triple underscore special notation <tt>:column___alias</tt> or <tt>:table__column___alias</tt>:
 
   items.literal(:price___p)
   # price AS p
@@ -488,6 +488,10 @@ You can use the <tt>Sequel.as</tt> method to alias arbitrary expressions, not ju
   items.literal(Sequel.as(DB[:posts].select{max(id)}, :p))
   # (SELECT max(id) FROM posts) AS p
 
+You can turn off the splitting of symbols containing double and triple underscores, and treat all symbols as regular identifiers, by using:
+
+  Sequel.split_symbols = false
+
 == Sequel Models
 
 A model class wraps a dataset, and an instance of that class wraps a single record in the dataset.

data/doc/active_record.rdoc

@@ -260,7 +260,7 @@ You just use:
 At the instance level, this means that if you select columns that aren't in the models table, you need to use <tt>Model#[]</tt> to access them:
 
   album = Album.join(:artist, :id=>:artist_id).
-   select(:albums__id, :albums__name, :artists__name___artist).first
+   select{[albums[:id], albums[:name], artists[:name].as(:artist)]}.first
    # SELECT albums.id, albums.name, artists.name AS artist
 
   album.artist # Error!

data/doc/advanced_associations.rdoc

@@ -50,12 +50,12 @@ These can be used like this:
     
   # Only returns albums that have sold more than 500,000 copies
   Artist.one_to_many :gold_albums, :class=>:Album, \
-    :graph_block=>proc{|j,lj,js| Sequel.qualify(j, :copies_sold) > 500000}
+    :graph_block=>proc{|j,lj,js| Sequel[j][:copies_sold] > 500000}
     
   # Handles the case where the tables are associated by a case insensitive name string
   Artist.one_to_many :albums, :key=>:artist_name, \
     :graph_only_conditions=>nil, \
-    :graph_block=>proc{|j,lj,js| {Sequel.function(:lower, Sequel.qualify(j, :artist_name))=>Sequel.function(:lower, Sequel.qualify(lj, :name))}}
+    :graph_block=>proc{|j,lj,js| {Sequel.function(:lower, Sequel[j][:artist_name])=>Sequel.function(:lower, Sequel[lj][:name])}}
     
   # Handles the case where both key columns have the name artist_name, and you want to use
   # a JOIN USING
@@ -73,8 +73,8 @@ ordered by the albums name, you can do:
 
   albums = Artist.
     eager_graph(:albums).
-    where(Sequel.like(:albums__name, 'A%')).
-    order(:albums__name).
+    where{Sequel.like(albums[:name], 'A%')}.
+    order{albums[:name]}.
     all
 
 For lazy loading (e.g. Model[1].association), the <tt>:dataset</tt> option can be used
@@ -780,16 +780,16 @@ What you want to do is get all songs for a given artist, ordered by the song's
 name, with no duplicates?
 
   class Artist < Sequel::Model
-    one_to_many :songs, :order=>:songs__name, \
+    one_to_many :songs, :order=>Sequel[:songs][:name], \
       :dataset=>proc{Song.select_all(:songs).join(Lyric, :id=>:lyric_id, id=>[:composer_id, :arranger_id, :vocalist_id, :lyricist_id])}, \
       :eager_loader=>(proc do |eo|
         h = eo[:id_map]
         ids = h.keys
         eo[:rows].each{|r| r.associations[:songs] = []}
         Song.select_all(:songs).
-          select_append(:lyrics__composer_id, :lyrics__arranger_id, :lyrics__vocalist_id, :lyrics__lyricist_id).
+          select_append{[lyrics[:composer_id], lyrics[:arranger_id], lyrics[:vocalist_id], lyrics[:lyricist_id]}.
           join(Lyric, :id=>:lyric_id){Sequel.or(:composer_id=>ids, :arranger_id=>ids, :vocalist_id=>ids, :lyricist_id=>ids)}.
-          order(:songs__name).all do |song|
+          order{songs[:name]}.all do |song|
           [:composer_id, :arranger_id, :vocalist_id, :lyricist_id].each do |x|
             recs = h[song.values.delete(x)]
             recs.each{|r| r.associations[:songs] << song} if recs

data/doc/association_basics.rdoc

@@ -993,7 +993,7 @@ columns that have the same name in both the join table and the associated
 table.  Example:
 
   Artist.one_to_many :albums, :select=>[:id, :name]
-  Album.many_to_many :tags, :select=>[Sequel[:tags].*, :albums_tags__number]
+  Album.many_to_many :tags, :select=>[Sequel[:tags].*, Sequel[:albums_tags][:number]]
 
 ==== :limit
 
@@ -1332,11 +1332,11 @@ association based on dependent associations:
 
   Artist.one_to_many :albums_with_short_tracks, :class=>:Album,
    :eager_graph=>:tracks do |ds|
-    ds.where{tracks__seconds < 120}
+    ds.where{tracks[:seconds] < 120}
   end
   Artist.one_to_many :albums_by_track_name, :class=>:Album,
    :eager_graph=>:tracks do |ds|
-    ds.order(:tracks__name)
+    ds.order{tracks[:name]}
   end
 
 You can also use a hash or array of arguments for :eager_graph, similar to
@@ -1364,7 +1364,7 @@ via eager_graph.  This is useful to specify conditions that can't be specified
 in a hash or array of two element arrays.
 
   Artist.one_to_many :gold_albums, :class=>:Album,
-    :graph_block=>proc{|j,lj,js| Sequel.qualify(j, :copies_sold) > 500000}
+    :graph_block=>proc{|j,lj,js| Sequel[j][:copies_sold] > 500000}
 
 ==== :graph_join_type
 
@@ -1396,8 +1396,8 @@ where the artist's name differs in case:
 
   Artist.one_to_many :albums, :key=>:artist_name, 
     :graph_only_conditions=>nil, 
-    :graph_block=>proc{|j,lj,js| {Sequel.function(:lower, Sequel.qualify(j, :artist_name))=>
-      Sequel.function(:lower, Sequel.qualify(lj, :name))}}
+    :graph_block=>proc{|j,lj,js| {Sequel.function(:lower, Sequel[j][:artist_name])=>
+      Sequel.function(:lower, Sequel[lj][:name])}}
 
 Note how :graph_only_conditions is set to nil to ignore any existing conditions,
 and :graph_block is used to set up the case insensitive comparison.
@@ -1504,7 +1504,7 @@ has received a bachelor's degree (degree starting with B):
 
   Person.many_to_many :bachelor_degree_colleges, :class=>:College,
     :join_table=>:degrees_received,
-    :graph_join_table_block=>proc{|j,lj,js| Sequel.qualify(j, :degree).like('B%')}
+    :graph_join_table_block=>proc{|j,lj,js| Sequel[j][:degree].like('B%')}
 
 This should be done when graphing the join table, instead of when graphing the
 final table, as :degree is a column of the join table.

data/doc/cheat_sheet.rdoc

@@ -129,7 +129,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   # SELECT * FROM items
   # LEFT OUTER JOIN categories ON categories.id = items.category_id
 
-  DB[:items].join(:categories, :id => :category_id).join(:groups, :id => :items__group_id) 
+  DB[:items].join(:categories, :id => :category_id).join(:groups, :id => Sequel[:items][:group_id]) 
   # SELECT * FROM items
   # INNER JOIN categories ON categories.id = items.category_id
   # INNER JOIN groups ON groups.id = items.group_id
@@ -170,8 +170,10 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 == Aliasing
 
   DB[:items].select(Sequel.as(:name, :item_name))
-  DB[:items].select(:name___item_name)
-  DB[:items___items_table].select(:items_table__name___item_name)
+  DB[:items].select{name.as(:item_name)}
+  # SELECT name AS item_name FROM items
+
+  DB[Sequel[:items].as(:items_table)].select{items_table[:name].as(:item_name)}
   # SELECT items_table.name AS item_name FROM items AS items_table
 
 == Transactions

data/doc/core_extensions.rdoc

@@ -170,11 +170,11 @@ Symbol#qualify qualifies the identifier (e.g. a column) with a another identifie
 
   :column.qualify(:table) # SQL: table.column
 
-Alternative: Sequel.qualify:
+Alternative: Sequel[][]:
 
-  Sequel.qualify(:table, :column)
+  Sequel[:table][:column]
 
-Note the reversed order of the arguments.  For the Symbol#qualify method, the argument is the qualifier, while for Sequel.qualify, the qualifier is the first argument.
+Note the reversed order of the arguments.  For the Symbol#qualify method, the argument is the qualifier, while for Sequel[][], the first [] is the qualifier, and the second [] is the identifier.
 
 ==== like
 

data/doc/dataset_filtering.rdoc

@@ -47,7 +47,7 @@ Sequel can check for null values:
 
 Or compare two columns:
 
-  items.where(:x => :some_table__y).sql
+  items.where{{:x => some_table[:y]}}.sql
   #=> "SELECT * FROM items WHERE (x = some_table.y)"
 
 And also compare against multiple values:

data/doc/object_model.rdoc

@@ -126,21 +126,29 @@ For example, ruby symbols represent SQL identifiers (tables, columns, schemas):
   :table  # "table"
   :column # "column"
 
-However, they can also represent qualified identifiers by including a double
-underscore inside a symbol:
+By default, Sequel supports splitting symbols using double or triple underscores
+to represent qualified and aliased identifiers.  A symbol with a double underscore
+is treated as a qualified identifier:
 
   :table__column # "table"."column"
 
-They can also represent an aliased identifier by including a triple underscore
-inside a symbol:
+A symbol with a triple underscore is treated as an aliased identifier:
 
   :column___alias # "column" AS "alias"
 
-You can combine both qualification and aliasing by using a double underscore
-and a triple underscore:
+A symbol with a double underscore followed by a triple underscore is treated
+as an aliased qualified identifer:
 
   :table__column___alias # "table"."column" AS "alias"
 
+By allowing the creation of qualified and aliased identifiers via symbols,
+Sequel makes it simpler to represent more SQL expressions.  However, if you
+are using double or triple underscores in your own identifiers, Sequel's
+automatic splitting of identifiers can be problematic, in which case you
+may want to turn them off via:
+
+  Sequel.split_symbols = false
+
 === Integer, Float, BigDecimal, String, Date, Time, DateTime
 
 Ruby's Integer, Float, BigDecimal, String, Date, Time, and DateTime classes
@@ -283,6 +291,7 @@ Sequel::SQL::QualifiedIdentifier objects represent qualified identifiers:
 The following shortcuts exist for creating Sequel::SQL::QualifiedIdentifier objects:
 
   Sequel[:table__column]
+  Sequel[:table][:column]
   Sequel.qualify(:table, :column)
   :column.qualify(:table) # core_extensions extension
 
@@ -302,7 +311,7 @@ The following shortcuts exist for creating Sequel::SQL::AliasedExpression object
   Sequel[:column___alias]
   Sequel.as(:column, :alias)
   Sequel.as(:column, :alias, [:column_alias1, :column_alias2])
-  :column.as(:alias) # core_extensions extension
+  :column.as(:alias) # core_extensions or symbol_as extension
   
 === Sequel::SQL::ComplexExpression
 

data/doc/postgresql.rdoc

@@ -160,7 +160,7 @@ Sequel has built in support for creating and dropping PostgreSQL schemas, proced
   DB.drop_function(:set_updated_at)
   # DROP FUNCTION set_updated_at()
 
-  DB.create_trigger(:table, :trg_updated_at, :set_updated_at, :events=>:update, :each_row=>true, :when => {:new__updated_at => :old__updated_at})
+  DB.create_trigger(:table, :trg_updated_at, :set_updated_at, :events=>:update, :each_row=>true, :when => {Sequel[:new][:updated_at] => Sequel[:old][:updated_at]})
   # CREATE TRIGGER trg_updated_at BEFORE UPDATE ON "table" FOR EACH ROW WHEN ("new"."updated_at" = "old"."updated_at") EXECUTE PROCEDURE set_updated_at()
   DB.drop_trigger(:table, :trg_updated_at)
   # DROP TRIGGER trg_updated_at ON "table"
@@ -231,7 +231,7 @@ If you want to update the existing row instead of ignoring the constraint violat
 can pass an +:update+ option with a hash of values to update.  You must pass either the
 +:target+ or +:constraint+ options when passing the +:update+ option:
 
-  DB[:table].insert_conflict(:target=>:a, :update=>{:b=>:excluded__b}).insert(:a=>1, :b=>2)
+  DB[:table].insert_conflict(:target=>:a, :update=>{:b=>Sequel[:excluded][:b]}).insert(:a=>1, :b=>2)
   # INSERT INTO TABLE (a, b) VALUES (1, 2)
   # ON CONFLICT (a) DO UPDATE SET b = excluded.b
  
@@ -240,7 +240,7 @@ Additionally, if you only want to do the update in certain cases, you can specif
 conditions, the constraint violation will be ignored, but the row will not be updated:
 
   DB[:table].insert_conflict(:constraint=>:table_a_uidx,
-    :update=>{:b=>:excluded__b}, :update_where=>{:table__status_id=>1}).insert(:a=>1, :b=>2)
+    :update=>{:b=>Sequel[:excluded][:b]}, :update_where=>{Sequel[:table][:status_id]=>1}).insert(:a=>1, :b=>2)
   # INSERT INTO TABLE (a, b) VALUES (1, 2)
   # ON CONFLICT ON CONSTRAINT table_a_uidx
   # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)

data/doc/querying.rdoc

@@ -804,7 +804,7 @@ is wrong as the foreign key <tt>tracks.album_id</tt> refers to <tt>albums.id</tt
 <tt>artists.id</tt>.  To fix this, you need to explicitly qualify when joining:
 
   Album.join(:artists, :id=>:artist_id).
-   join(:tracks, :album_id=>:albums__id)
+   join(:tracks, :album_id=>Sequel[:albums][:id])
   # SELECT * FROM albums
   # INNER JOIN artists ON artists.id = albums.artist_id
   # INNER JOIN tracks ON tracks.album_id = albums.id
@@ -876,7 +876,7 @@ and artists tables, but only want albums where the artist's name
 comes before the album's name.
 
   Album.join(:artists, :id=>:artist_id) do |j, lj, js|
-    Sequel.qualify(j, :name) < Sequel.qualify(lj, :name)
+    Sequel[j][:name] < Sequel[lj][:name]
   end
   # SELECT * FROM albums INNER JOIN artists
   # ON artists.id = albums.artist_id
@@ -904,7 +904,7 @@ number of old albums.
 Using multiple FROM tables and setting conditions in the WHERE clause is
 an old-school way of joining tables:
 
-  DB.from(:albums, :artists).where(:artists__id=>:albums__artist_id)
+  DB.from(:albums, :artists).where{{artists[:id]=>albums[:artist_id]}}
   # SELECT * FROM albums, artists WHERE artists.id = albums.artist_id
 
 === Using the current dataset in a subselect

data/doc/release_notes/4.40.0.txt

@@ -0,0 +1,179 @@
+= New Features
+
+* A Sequel.split_symbols setting has been added.  This setting is
+  true by default, so there is no change to backwards compatibility
+  by default.  However, users can now do:
+
+    Sequel.split_symbols = false
+
+  to disable the splitting of symbols.  This will make Sequel no
+  longer treat symbols with double or triple underscores as qualified
+  or aliased identifiers, instead treating them as plain identifiers.
+  It will also make Sequel no longer treat virtual row methods with
+  double underscores as qualified identifiers.  Examples:
+
+    # Sequel.split_symbols = true
+    :column                    # "column"
+    :table__column             # "table"."column"
+    :column___alias            # "column" AS "alias"
+    :table__column___alias     # "table"."column" AS "alias"
+    Sequel.expr{table__column} # "table"."column"
+
+    # Sequel.split_symbols = false
+    :column                    # "column"
+    :table__column             # "table__column"
+    :column___alias            # "column___alias"
+    :table__column___alias     # "table__column___alias"
+    Sequel.expr{table__column} # "table__column"
+
+  Disabling symbol splitting can make things much easier if leading
+  trailing, double, or triple underscores are used in identifiers
+  in your database.
+
+  Disabling symbol splitting makes Sequel simpler, even if it does
+  make it slightly less easy to create qualified and aliased
+  identifiers.  It is possible that the symbol splitting will be
+  disabled by default starting in Sequel 5.
+
+  Note that due to Database symbol literal caching, you should not
+  change the Sequel.split_symbols setting after creating a
+  Database instance.
+
+* SQL::Identifier#[] and SQL::QualifiedIdentifier#[] have been added
+  for creating qualified identifiers.  This makes it easier and more
+  natural to create qualified identifiers from existing identifiers.
+  Previously, you could do:
+
+    Sequel[:column].qualify(:table)
+
+  You can now use the more natural:
+
+    Sequel[:table][:column]
+
+  This can also be used in virtual rows:
+
+    Sequel.expr{table[:column]}
+
+  This offers a easy way to create qualified identifers when symbol
+  splitting has been disabled.
+
+* A symbol_aref extension has been added, allowing the use of
+  Symbol#[] to create qualified identifiers if passed a Symbol,
+  SQL::Identifier, or SQL::QualifiedIdentifier.  This doesn't
+  break any existing ruby behavior, as ruby currrently raises
+  an exception in such cases.  Example:
+  
+    :table[:column] # "table"."column"
+
+  This extension can make it easier to create qualified identifiers
+  if symbol splitting is disabled.
+
+  A symbol_aref_refinement extension has also been added, which
+  adds a refinement version of the extension that can be enabled via:
+
+    using Sequel::SymbolAref
+
+* A symbol_as extension has been added, which adds the Symbol#as method
+  to create aliased identifiers.  This was previously part of the core
+  extensions, but has been separated so it can be included by itself.
+  Example:
+
+    :column.as(:alias) # "column" AS "alias"
+
+  This extension can make it easier to create aliased identifiers if
+  symbol splitting is disabled.
+
+  A symbol_as_refinement extension has also been added, which
+  adds a refinement version of the extension that can be enabled via:
+
+    using Sequel::SymbolAs
+
+* An s extension has been added, which adds the Sequel::S module,
+  containing a private #S method that calls Sequel.expr.  You can
+  include this module in any module or class where you would like the
+  S method to be available:
+
+    class Album < Sequel::Model
+      extend Sequel::S
+      one_to_many :tracks, :order=>S(:number).desc
+    end
+
+  You can include this in Object if you want the S method to be
+  available globally:
+
+    Object.send(:include, Sequel::S)
+
+  Sequel::S also works if it is used as a refinement, adding the S
+  method to Object while the refinement is active:
+
+    using Sequel::S
+
+  This extension can make it easier to create qualified and aliased
+  identifiers if symbol splitting is disabled:
+
+    S(:table)[:column]
+    S(:column).as(:alias)
+
+* Dataset#insert_conflict on PostgreSQL now supports a :conflict_where
+  option, allowing for the handling of insert conflicts when using a
+  partial unique index:
+
+    DB[:table].insert_conflict(:target=>:a,
+      :conflict_where=>{:c=>true}).insert(:a=>1, :b=>2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT (a) WHERE (c IS TRUE) DO NOTHING
+
+= Other Improvements
+
+* Sequel no longer attempts to combine arguments for non-associative
+  operators, as doing so leads to invalid code in cases such as:
+
+    Sequel.expr{column1 - (column2 - 1)}
+
+* Sequel now automatically adds NOT NULL constraints on columns when
+  adding a primary key constraint on the columns, if the database
+  doesn't handle that situation correctly.
+
+* Database#rollback_checker now returns a thread-safe object.
+
+* SQL::QualifiedIdentifier#initialize now converts SQL::Identifier
+  arguments to strings, fixing usage of such objects in the
+  schema methods.
+
+* The prepared_statements plugin now correctly handles lookup by
+  primary key on models with joined datasets.
+
+* The dataset_associations plugin now handles many_through_many and
+  one_through_many associations that use a single join table.  Note
+  there is no reason to create such associations, as many_to_many
+  and one_through_one associations will work for such cases.
+
+* The insert_returning_select plugin now handles cases where the
+  model doesn't have a valid dataset, fixing usage with the
+  lazy_attributes and dataset_associations plugins, and potentially
+  other plugins.
+
+* The column_select plugin no longer raises an exception if the
+  model's table does not exist.
+
+* The class_table_inheritance plugin now works when the
+  prepared_statements plugin is also used.
+
+* Some adapters now avoid thread-safety issues during loading on
+  ruby implementations without a GVL by avoiding the modification of
+  shared datastructures.
+
+* When using Database#tables with the :qualify=>true option on
+  PostgreSQL, table names with double or triple underscores are
+  now handled correctly.
+
+= Backwards Compatibility
+
+* The following Dataset constants are now frozen: NON_SQL_OPTIONS,
+  ACTION_METHODS, QUERY_METHODS, CONDITIONED_JOIN_TYPES,
+  UNCONDITIONED_JOIN_TYPES, and JOIN_METHODS.  Of these,
+  NON_SQL_OPTIONS was previously modified in a non-thread-safe manner
+  by some adapters.  External adapters should switch to having the
+  adapter's dataset non_sql_options method return an array of options
+  that do not affect the SELECT SQL for the adapter's datasets, rather
+  than modifying NON_SQL_OPTIONS.