sequel 3.48.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 339910a226e23b822c21d4ed5c0ec1b656e02c42
-  data.tar.gz: 62b3fc6e7c75d5edb560b97e9cccd4824c59fe3d
+  metadata.gz: 3f1f6d7107eb83ff3840572817d310bdf10371ad
+  data.tar.gz: 4f04ad59f41290e20d2aba5af08947ef0ceb52e0
 SHA512:
-  metadata.gz: a594024cffd3c08ef06a75e249faf27d86296164f882e56d9f01969078ac918362112422df36af749d35c05cc6b93de0555d282f5a3d2ac1ae2336c89d3cb475
-  data.tar.gz: 4f500ea855dc1bb0cc2733e17a5016deeaeafa353a067bebe6dfd2601a0822da4e5f71673d13e69eebd0daed5186d20a9caa4f35feb608aac0c8a2a379b76867
+  metadata.gz: 355ac8d6ada27fbb499219b662c1a0a884777b0f6e95e98681415acc321bcef3178e494e5252fffa3417b086c3fcc2c04bd6fa9f45fbdc7d0f894fe5883fcbc8
+  data.tar.gz: 5cb1f4ef00bfaabc721e75baf1b02756e2b82a9f9c1fa2c241f01a6d717bee27c6d37b7c0bfd6876c85d9d0b78447a1d57ee9e2f6906902cf079f9d1773c0c9d

data/CHANGELOG

@@ -1,3 +1,117 @@
+=== 4.0.0 (2013-07-01)
+
+* Correctly parse composite primary keys on SQLite 3.7.16+ (jeremyevans)
+
+* Recognize another disconnect error in the jdbc/oracle adapter (jeremyevans)
+
+* Add pg_json_ops extension for calling JSON functions and operators in PostgreSQL 9.3+ (jeremyevans)
+
+* Handle non-JSON plain strings, integers, and floats in PostgreSQL JSON columns in pg_json extension (jeremyevans)
+
+* Dataset#from now accepts virtual row blocks (jeremyevans)
+
+* Add Database#refresh_view on PostgreSQL to support refreshing materialized views (jeremyevans)
+
+* Support the Database#drop_view :if_exists option on PostgreSQL (jeremyevans)
+
+* Support the Database#{create,drop}_view :materialized option for creating materialized views in PostgreSQL 9.3+ (jeremyevans)
+
+* Support the Database#create_view :recursive option for creating recursive views in PostgreSQL 9.3+ (jeremyevans)
+
+* Support the Database#create_view :columns option for using explicit columns (jeremyevans)
+
+* Support the Database#create_schema :owner and :if_not_exists options on PostgreSQL (jeremyevans)
+
+* Support :index_type=>:gist option to create GIST full text indexes on PostgreSQL (jeremyevans)
+
+* Add Postgres::ArrayOp#replace for the array_replace function in PostgreSQL 9.3+ (jeremyevans)
+
+* Add Postgres::ArrayOp#remove for the array_remove function in PostgreSQL 9.3+ (jeremyevans)
+
+* Add Postgres::ArrayOp#hstore for creating hstores from arrays (jeremyevans)
+
+* Make Postgres::ArrayOp#[] return ArrayOp if given a range (jeremyevans)
+
+* Ensure that CHECK constraints are surrounded with parentheses (jeremyevans)
+
+* Ensure Dataset#unbind returned variable hash uses symbol keys (jeremyevans)
+
+* Add pg_array_associations plugin, for associations based on PostgreSQL arrays containing foreign keys (jeremyevans)
+
+* Add Sequel.deep_qualify, for easily doing a deep qualification (jeremyevans)
+
+* Enable use of window functions for limited eager loading by default (jeremyevans)
+
+* Handle offsets correctly when eager loading one_to_one associations (jeremyevans)
+
+* Raise exception for infinite and NaN floats on MySQL (jeremyevans) (#677)
+
+* Make dataset string literalization that requires database connection use dataset's chosen server (jeremyevans)
+
+* Make sure an offset without a limit is handled correctly when eager loading (jeremyevans)
+
+* Allow providing ranges as subscripts for array[start:end] (jeremyevans)
+
+* Prepare one_to_one associations in the prepared_statements_associations plugin (jeremyevans)
+
+* Use prepared statements when the association has :conditions in the prepared_statements_associations plugin (jeremyevans)
+
+* Fix prepared statement usage in some additional cases in the prepared_statements_associations plugin (jeremyevans)
+
+* Hex escape blob input on MySQL (jeremyevans)
+
+* Handle more disconnect errors when using the postgres adapter with the postgres-pr driver (jeremyevans)
+
+* Model#setter_methods private method now accepts 1 argument instead of 2 (jeremyevans)
+
+* Model#set_restricted and #update_restricted private methods now accept 2 arguments instead of 3 (jeremyevans)
+
+* ungraphed on an eager_graph dataset now resets the original row_proc (jeremyevans)
+
+* eager_graph now returns a naked dataset (jeremyevans)
+
+* All behavior deprecated in Sequel 3.48.0 has been removed (jeremyevans)
+
+* Make adapter/integration spec environment variables more consistent (jeremyevans)
+
+* Sequel no longer provides default databases for adapter/integration specs (jeremyevans)
+
+* Model#save no longer calls #_refresh internally (jeremyevans)
+
+* Model#set_all and #update_all can now update the primary key (jeremyevans)
+
+* Integrate many_to_one_pk_lookup and association_autoreloading plugins into main associations plugin (jeremyevans)
+
+* Make defaults_setter plugin operate in a lazy manner (jeremyevans)
+
+* Plugins now extend the model class with ClassMethods before including InstanceMethods (jeremyevans)
+
+* Remove Model::EMPTY_INSTANCE_VARIABLES (jeremyevans)
+
+* Model.raise_on_typecast_failure now defaults to false (jeremyevans)
+
+* Model#_save private method now only takes a single argument (jeremyevans)
+
+* Remove Dataset#columns_without_introspection from columns_introspection extension (jeremyevans)
+
+* Make boolean prepared statement arguments work on sqlite adapter when integer_booleans is true (jeremyevans)
+
+* Make Database#tables and #views reflect search_path on PostgreSQL (jeremyevans)
+
+* SQLite now defaults to true for integer_booleans and false for use_timestamp_timezones (jeremyevans)
+
+* Make the default value for most option hashes a shared frozen hash (jeremyevans)
+
+* Remove Sequel::NotImplemented exception (jeremyevans)
+
+* Automatically alias single expressions in Dataset#get, #select_map, and #select_order_map, to work around possible DoS issues (jeremyevans)
+
+* Use a connection queue instead of stack by default for threaded connection pools (jeremyevans)
+
+* Remove SQL::SQLArray alias for SQL::ValueList (jeremyevans)
+
+* Remove SQL::NoBooleanInputMethods empty module (jeremyevans)
+
 === 3.48.0 (2013-06-01)
 
 * Make named_timezones extension usable by databases allowing timezone strings to be given to Database#timezone= (jeremyevans)

data/Rakefile

@@ -148,7 +148,7 @@ begin
     if RUBY_VERSION < '1.9'
       t = spec.call("#{name}_cov", files, "#{d} with coverage")
       t.rcov = true
-      t.rcov_opts = File.read("spec/rcov.opts").split("\n")
+      t.rcov_opts = File.file?("spec/rcov.opts") ? File.read("spec/rcov.opts").split("\n") : []
       b.call(t) if b
     else
       desc "#{d} with coverage"
@@ -167,22 +167,25 @@ begin
   spec.call("spec_model", Dir["spec/model/*_spec.rb"], "Run model specs")
   spec.call("_spec_model_no_assoc", Dir["spec/model/*_spec.rb"].delete_if{|f| f =~ /association|eager_loading/}, '')
   spec_with_cov.call("spec_core_ext", ["spec/core_extensions_spec.rb"], "Run core extensions specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|adapters|connection_pool|database|dataset|model)"')}
-  spec_with_cov.call("spec_plugin", Dir["spec/extensions/*_spec.rb"], "Run extension/plugin specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|adapters|connection_pool|database|dataset|model)"')}
+  spec_with_cov.call("spec_plugin", Dir["spec/extensions/*_spec.rb"].sort_by{rand}, "Run extension/plugin specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|adapters|connection_pool|database|dataset|model)"')}
   spec_with_cov.call("spec_integration", Dir["spec/integration/*_test.rb"], "Run integration tests")
 
   %w'postgres sqlite mysql informix oracle firebird mssql db2'.each do |adapter|
     spec_with_cov.call("spec_#{adapter}", ["spec/adapters/#{adapter}_spec.rb"] + Dir["spec/integration/*_test.rb"], "Run #{adapter} specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|connection_pool|database|dataset|model|extensions|plugins)"')}
   end
 
-  task :spec_travis=>[:spec, :spec_plugin, :spec_core_ext, :spec_sqlite] do
+  task :spec_travis=>[:spec, :spec_plugin, :spec_core_ext] do
     if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-      ENV['SEQUEL_PG_SPEC_DB'] = "jdbc:postgresql://localhost/sequel_test?user=postgres"
-      ENV['SEQUEL_MY_SPEC_DB'] = "jdbc:mysql://localhost/sequel_test?user=root"
+      ENV['SEQUEL_SQLITE_URL'] = "jdbc:sqlite::memory:"
+      ENV['SEQUEL_POSTGRES_URL'] = "jdbc:postgresql://localhost/sequel_test?user=postgres"
+      ENV['SEQUEL_MYSQL_URL'] = "jdbc:mysql://localhost/sequel_test?user=root"
     else
-      ENV['SEQUEL_PG_SPEC_DB'] = "postgres://localhost/sequel_test?user=postgres"
-      ENV['SEQUEL_MY_SPEC_DB'] = "mysql2://localhost/sequel_test?user=root"
+      ENV['SEQUEL_SQLITE_URL'] = "sqlite:/"
+      ENV['SEQUEL_POSTGRES_URL'] = "postgres://localhost/sequel_test?user=postgres"
+      ENV['SEQUEL_MYSQL_URL'] = "mysql2://localhost/sequel_test?user=root"
     end
 
+    Rake::Task['spec_sqlite'].invoke
     Rake::Task['spec_postgres'].invoke
     Rake::Task['spec_mysql'].invoke
   end

data/doc/association_basics.rdoc

@@ -1673,18 +1673,19 @@ plugin.
 
 This setting determines what strategy to use for loading the associations
 that use the :limit setting to limit the number of returned records. You
-can't use LIMIT directly, since you want a limit for each associated
-record, not a LIMIT on the number of records returned by the dataset.
-
-By default, no strategy is used for one_to_one associations, and
-the :ruby strategy is used for *_many associations, which does a simple
-array slice after loading the associated records.  That doesn't provide
-a performance advantage, since all records are still loaded from the
-database, but it at least makes sure the cached records are accurately
-limited as they would be in the lazy load case.
-
-The reason no strategy is used by default for one_to_one associations
-is that none is needed for a true one_to_one association (since there
+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_to_one association uses an offset, 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_to_one associations without offsets, 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
@@ -1693,17 +1694,18 @@ 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.
 
-You can set a value of +true+ for this option to have Sequel select what
-it thinks is the best way of limiting the records for your database.  You
-can also specify a symbol to manually choose a strategy.  The available
+In general, Sequel picks an appropriate strategy, so it is not usually
+necessary to specify a specific strategy.  The exception is for one_to_one
+associations where there is more than one associated record per current
+record.  For those, you should probably specify true to this option to have
+Sequel pick an appropriate strategy.
+
+You can also specify a symbol to manually choose a strategy.  The available
 strategies are:
 
 :distinct_on :: Uses DISTINCT ON to ensure only the first matching record
-                is loaded (one_to_one associations only). This is used by
-                default on PostgreSQL.
-:window_function :: Uses window functions if the database supports it.
-                    This is used by default on databases that support window
-                    functions.
-:ruby :: Uses ruby array slicing to emulate database limiting (*_many
-         associations only).  This is the default if the database doesn't
-         support window functions.
+                is loaded (only used for one_to_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.

data/doc/code_order.rdoc

@@ -18,6 +18,13 @@ be executed unless the library has been required first. Example:
 Global extensions are loaded with Sequel.extension, and affect
 other parts of Sequel or the general ruby environment.  It's not
 necessary to load them first, but it is a recommended practice.
+
+The exception to this is global extensions that integrate with
+Database-specific extensions, where the Database-specific
+extension should be loaded first (such as some of the pg_*
+extensions).  In those cases, the global extensions should be
+loaded after the Database-specific extensions.
+
 Example:
 
   Sequel.extension :blank

data/doc/core_extensions.rdoc

@@ -36,16 +36,6 @@ All of Sequel's extensions to the core classes are stored in Sequel's core_exten
 
   Sequel.extension :core_extensions
 
-For backwards compatibility, the core_extensions are loaded by default in Sequel 3.  Starting in Sequel 4, the core extensions will no longer be loaded by default, so you will have to load the core_extensions extension manually using the above code.  If you plan to use the core extensions, it's recommended that you manually load the extension, even in Sequel 3.  If you do not plan to use the core extensions, you can change from:
-
-  require 'sequel'
-
-to:
-
-  require 'sequel/no_core_ext'
-
-which will load Sequel without the core extensions.
-
 == No Internal Dependency
 
 Sequel has no internal dependency on the core extensions.  This includes Sequel's core, Sequel::Model, and all plugins and extensions that ship with Sequel.  However, it is possible that external plugins and extensions will depend on the core extensions.  Such plugins and extensions should be updated so that they no longer depend on the core extensions.

data/doc/object_model.rdoc

@@ -504,18 +504,21 @@ The following shortcuts exist for creating Sequel::SQL::OrderedExpression object
 === Sequel::SQL::Subscript
 
 Sequel::SQL::Subscript objects represent SQL database array access.  They take an
-expression and an array of indexes:
+expression and an array of indexes (or a range for an SQL array slice):
 
   Sequel::SQL::Subscript.new(:a, [1]) # "a"[1]
   Sequel::SQL::Subscript.new(:a, [1, 2]) # "a"[1, 2]
+  Sequel::SQL::Subscript.new(:a, [1..2]) # "a"[1:2]
 
 The following shortcuts exist for creating Sequel::SQL::Subscript objects:
 
   Sequel.subscript(:a, 1)
   Sequel.subscript(:a, 1, 2)
+  Sequel.subscript(:a, 1..2)
 
   :a.sql_subscript(1) # core_extensions extension
   :a.sql_subscript(1, 2) # core_extensions extension
+  :a.sql_subscript(1..2) # core_extensions extension
   
 === Sequel::SQL::VirtualRow
 

data/doc/querying.rdoc

@@ -678,13 +678,13 @@ filters the results after the grouping has been applied, instead of
 before.  One possible use is if you only wanted to return artists
 who had at least 10 albums:
 
-  Album.group_and_count(:artist_id).having{count >= 10}
+  Album.group_and_count(:artist_id).having{count(:*){} >= 10}
   # SELECT artist_id, count(*) AS count FROM albums
-  # GROUP BY artist_id HAVING count >= 10
+  # GROUP BY artist_id HAVING count(*) >= 10
 
 Both the WHERE clause and the HAVING clause are removed by +unfiltered+:
 
-  Album.group_and_count(:artist_id).having{count >= 10}.
+  Album.group_and_count(:artist_id).having{count(:*){} >= 10}.
    where(:name.like('A%')).unfiltered
   # SELECT artist_id, count(*) AS count FROM albums GROUP BY artist_id
 

data/doc/release_notes/4.0.0.txt

@@ -0,0 +1,262 @@
+= Backwards Compatibility
+
+* All behavior resulting in deprecation messages in 3.48.0 has been
+  removed or modified.  If you plan on upgrading to Sequel 4.0.0 and
+  have not yet upgraded to 3.48.0, upgrade to 3.48.0 first, fix code
+  that results in deprecation warnings, and then upgrade to 4.0.0.
+
+* The threaded connection pools now default to
+  :connection_handling=>:queue.  You can manually set
+  :connection_handling=>:stack to get the previous behavior.
+
+* Model.raise_on_typecast_failure now defaults to false.  Set this to
+  true to get the previous behavior of raising typecast errors in the
+  setter methods.
+
+* Model#save no longer calls Model#_refresh or Model#set_values
+  internally after an insert.  Manual refreshes are now treated
+  differently than after creation refreshes.
+
+* On SQLite, integer_booleans now defaults to true.  Set this to
+  false to get the previous behavior of 't' for true and 'f' for
+  false.  Sequel will not automatically upgrade your data, users
+  are responsible for doing that if they want to switch the
+  integer_booleans setting.  Note that regardless of the setting,
+  Sequel will return the correct ruby values when retrieving the
+  rows.
+
+  Example Code to Migrate Existing Data:
+
+    DB[:table].where(:column=>'t').update(:column=>1)
+    DB[:table].where(:column=>'f').update(:column=>0)
+
+* On SQLite, use_timestamp_timezones is now false by default.  Set
+  this to true to get the previous behavior with timezone information
+  in timestamps. Sequel will not automatically upgrade your data,
+  users are responsible for doing that if they want to switch the
+  use_timestamp_timezones setting.  Note that regardless of the
+  setting, Sequel will return the correct ruby values when
+  retrieving the rows.
+
+* Using window functions when eagerly loading associations with
+  limits or offsets is now done automatically if the database
+  supports it.  Previously, this had to be enabled manually.  If
+  you would like to disable this optimization and just do the
+  slicing in ruby, set default_eager_limit_strategy = nil.
+
+* The default value for most option hash arguments is now an shared
+  empty frozen hash.  If you are overriding methods and modifying
+  option hashes, fix your code.
+
+* The defaults_setter plugin now works in a lazy manner instead of
+  an eager manner.  So calling the related method returns the
+  default value if there is no value stored, but Sequel does not
+  add the default values to the internal values hash, and will not
+  attempt to insert what it thinks is the default value when
+  saving the new object.
+
+* Model#set_all and #update_all now allow setting the primary key
+  columns.
+
+* The many_to_one_pk_lookup and association_autoreloading plugins
+  are now integrated into the default associations support.
+
+* Plugins now extend the class with ClassMethods before including
+  InstanceMethods in the class.
+
+* Dataset#get, #select_map, and #select_order_map now automatically
+  add aliases for unaliased expressions if given a single expression.
+
+* Database#tables and #views on PostgreSQL now check against
+  the current schemas in the search path.
+
+* Calling ungraphed on an eager_graph dataset will restore the
+  row_proc for that dataset.  This is not backwards compatible if
+  your method chain does:
+
+    dataset.eager_graph.naked.ungraphed
+
+  Switch such code to:
+
+    dataset.eager_graph.ungraphed.naked
+
+* The Model#set_restricted and #update_restricted private methods
+  have a slightly different API now.
+
+* Sequel::SQL::SQLArray alias for ValueList has been removed.
+
+* Sequel::SQL::NoBooleanInputMethods has been removed.
+
+* Sequel::NotImplemented has been removed.  Default implementations
+  of methods that used to raise this exception have been removed.
+
+* Sequel::Model::EMPTY_INSTANCE_VARIABLES has been removed.
+
+* The Sequel::Postgres::DatabaseMethods::EXCLUDE_SCHEMAS and
+  SYSTEM_TABLE_REGEXP constants have been removed.
+
+* Dataset#columns_without_introspection has been removed from the
+  columns_introspection extension.
+
+* Sequel no longer provides a default database for the adapter or
+  integration specs.  Additionally, if you are using spec_config.rb
+  to configure a database to use when adapter/integration testing,
+  you may need to modify it, as Sequel now uses the DB constant for
+  the database being tested.
+
+* The SEQUEL_MSSQL_SPEC_REQUIRE and SEQUEL_DB2_SPEC_REQUIRE
+  environment variables are no longer respected when
+  adapter/integration testing those databases.  Use RUBYOPT with the
+  -r flag.
+
+* In the 3.48.0 release notes, it was announced that
+  Dataset#join_table would default to :qualify=>:deep in 4.0.0.  This
+  change was made but reverted before the release of 4.0.0 as it was
+  determined too likely to break existing code, there was no
+  deprecation warning (since it just changed a setting), and the
+  benefit was minimal. You can make deep qualification the default by
+  by overriding Dataset#default_join_table_qualification.
+
+= New Features
+
+* A pg_array_associations plugin has been added, for creating
+  an association based on a PostgreSQL array column containing
+  foreign keys.  Example:
+
+    # Database schema:
+    #   tags                albums
+    #   :id (int4) <--\    :id
+    #   :name          \-- :tag_ids (int4[])
+    #                      :name
+
+    class Album
+      plugin :pg_array_associations
+      pg_array_to_many :tags
+    end
+    class Tag
+      plugin :pg_array_associations
+      many_to_pg_array :albums
+    end
+
+  This operates similarly to a many_to_many association, but does not
+  require a join table.  All of the usual Sequel association features
+  are supported, such as adding, removing, and clearing associations,
+  eager loading via eager and eager_graph, filtering by associations,
+  and dataset associations.
+
+  Note that until PostgreSQL gains the ability to enforce foreign key
+  constraints in array columns, this plugin is not recommended for
+  production use unless you plan on emulating referential integrity
+  constraints via triggers.
+  
+* Dataset#from now accepts virtual_row blocks, making it easy to use
+  with table returning functions:
+
+    DB.from{table_returning_function(arg)}
+
+* Sequel.deep_qualify has been added, for easily doing a deep
+  qualification of objects:
+
+    Sequel.deep_qualify(:table, Sequel.+(:column, 1))
+    # ("table"."column" + 1)
+    Sequel.deep_qualify(:table, Sequel.like(:a, 'b'))
+    # ("table"."a" LIKE 'b' ESCAPE '\')
+    
+* The prepared_statements_associations plugin now handles one_to_one
+  associations.
+
+* SQL::Subscript objects now handle ruby range arguments, operating as
+  an SQL array slice:
+
+    Sequel.subscript(:a, 1..2) # a[1:2]
+
+* Database#create_view now accepts a :columns option to provide
+  explicit column names for the view.
+
+* Postgres::ArrayOp#[] now returns an ArrayOp if given a range, since
+  a PostgreSQL array slice can be treated as an array.
+
+* Postgres::ArrayOp#hstore has been added for creating hstores from
+  PostgreSQL arrays.
+
+* When creating full text indexes on PostgreSQL, the :index_type=>:gist
+  option can be used to use a gist index instead of the default gin
+  index.  This can be useful if insert/update speed is more important
+  than lookup speed.
+
+* You can now provide the :owner option to Database#create_schema on
+  PostgreSQL to specify the owner of the schema.
+
+* You can now provide the :if_exists option to Database#drop_view
+  on PostgreSQL to not raise an error if the view doesn't exist.
+
+* The pg_json extension now handles non-JSON plain strings, integers
+  and floats in PostgreSQL JSON columns.
+
+= Support for New Features in PostgreSQL 9.3
+
+* A pg_json_ops extension has been added to support the new json
+  operators and functions.
+
+* Postgres::ArrayOp#replace and #remove have been added for using the
+  array_replace and array_remove functions.
+
+* You can now provide the :if_not_exists option when using
+  Database#create_schema on PostgreSQL to not raise an error if the
+  schema already exists.
+
+* Database#create_view now supports a :recursive option on PostgreSQL
+  for creating recursive views.
+
+* Database#create_view and #drop_view now support a :materialized option
+  on PostgreSQL for creating/dropping materialized views.
+
+* Database#refresh_view has been added on PostgreSQL for refreshing
+  materialized views.
+
+= Other Improvements
+
+* Check constraints are now always surrounded by parantheses, since that
+  is required by the SQL standard.  This fixes issues in the cases where
+  parentheses were not used automatically, such as when a function call
+  was used.
+
+* Using an offset without a limit when eager loading now works
+  correctly.
+
+* The prepared_statements_associations plugin now works correctly when
+  the associated class uses a filtered dataset.
+
+* The prepared_statements_associations plugin can now use a prepared
+  statement for cases where the association uses :conditions.
+
+* Boolean prepared statement arguments now work correctly in the sqlite
+  adapter when the integer_booleans setting is true.
+
+* Dataset#inspect on prepared statements now handles anonymous dataset
+  classes correctly.
+
+* When dataset string/blob literalization depends on having a database
+  connection and the dataset has an assigned server, a connection to
+  the assigned server is used.
+
+* More disconnect errors are now handled when using the postgres
+  adapter with the postgres-pr driver, and in the jdbc/oracle adapter.
+
+* Composite primary keys are now parsed correctly on SQLite 3.7.16+.
+
+* Blobs are now hex escaped on MySQL, which can solve some encoding
+  issues when blobs are used as literals in the same SQL query with
+  UTF-8 strings.
+
+* BigDecimals instances are now formatted nicer in the pretty_table
+  extension.
+
+* Sequel now raises an exception when attempting to literalize infinite
+  and NaN floats on MySQL.  In general, this would result in MySQL
+  raising an error, but in extreme cases it could have failed silently.
+
+* You can now use a NO_SEQUEL_PG environment variable to not
+  automatically require sequel_pg in the postgres adapter.
+
+* Dataset#unbind now always uses symbol keys in the bind variable hash.