sequel 4.36.0 → 5.61.0

data/doc/reflection.rdoc

@@ -6,7 +6,7 @@ Sequel supports reflection information in multiple ways.
 
 You can get the adapter in use using Database#adapter_scheme:
 
-  DB.adapter_scheme # e.g. :postgres, :jdbc, :odbc
+  DB.adapter_scheme # :postgres, :jdbc, :odbc
 
 == Database Connected To
 
@@ -97,17 +97,17 @@ You can get an array of association symbols with Model.associations:
 
   Model.associations # [:association1, :association2, ...]
 
-You can get the association reflection for a single association via the Model.association_reflection.  Association reflections are subclasses of hash, for ease of use and introspection (and backwards compatibility):
+You can get the association reflection for a single association via the Model.association_reflection.  Association reflections are subclasses of hash:
 
-  Model.association_reflection(:association1) # {:name=>:association1, :type=>:many_to_one, :model=>Model, ...}
+  Model.association_reflection(:association1) # #<Sequel::Model::Associations::ManyToOneAssociationReflection Model.many_to_one :association1>
 
 You can get an array of all association reflections via Model.all_association_reflections:
 
-  Model.all_association_reflections # [{:name=>:association1, :type=>:many_to_one, :model=>Model, ...}, ...]
+  Model.all_association_reflections # [#<Sequel::Model::Associations::ManyToOneAssociationReflection Model.many_to_one :association1>, ...]
 
 Finally, you can get a hash of association reflections via Model.association_reflections:
 
-  Model.association_reflections # {:association1=>{:name=>:association1, :type=>:many_to_one, :model=>Model, ...}, ...}
+  Model.association_reflections # {:association1=>#<Sequel::Model::Associations::ManyToOneAssociationReflection Model.many_to_one :association1>, ...}
 
 == Validations Defined
 
@@ -118,4 +118,3 @@ When using the validation_class_methods plugin, you can use the validation_refle
 Similarly, when using the constraint_validations plugin, you can use the constraint_validation_reflections class method:
 
   Model.constraint_validation_reflections[:column] # => [[:presence, {}], [:max_length, {:argument=>255, :message=>'is just too long'}]]
-

data/doc/release_notes/5.0.0.txt

@@ -0,0 +1,159 @@
+= Major Changes
+
+* Datasets are now frozen by default.  Since Sequel's inception,
+  datasets have used a method-chaining API that returned modified
+  copies, but previously they still supported direct mutation.  Now,
+  datasets are always frozen and cannot be mutated. This allows many
+  additional default optimizations related to caching, and provides
+  greater thread safety.
+
+    ds = DB[:table]
+
+    # Before
+    ds.row_proc = lambda{|h| h}
+
+    # Now
+    ds = ds.with_row_proc(lambda{|h| h})
+
+* Symbol splitting to create qualified and/or aliased identifiers is
+  now disabled by default.  While symbol splitting allowed for shorter
+  code, it was not obvious and caused significant issues when using
+  column names with embedded double or triple underscores.  Sequel now
+  offers many ways to create qualified and/or aliased identifiers.
+
+    # Before
+    :table__column          # "table"."column"
+
+    # Now
+    :table__column          # "table__column"
+    Sequel[:table][:column] # "table"."column"
+
+    # To get back historical behavior
+    Sequel.split_symbols = true
+
+* Sequel no longer allows the use of plain ruby strings as SQL code
+  fragments in the dataset filtering methods, as that makes it
+  easier to introduce SQL injection vulnerabilities.  You can use
+  Sequel.lit to create literal strings (SQL code fragments), which
+  makes it easier to do security auditing of applications using
+  Sequel.
+
+    # Before
+    DB[:table].where("column = 1").all
+
+    # Now 
+    DB[:table].where(Sequel.lit("column = 1")).all
+    # or better
+    DB[:table].where(column: 1).all
+
+    # To get back historical behavior
+    DB.extension :auto_literal_strings
+
+= Backwards Compatibility
+
+* All adapters, extensions, plugins, features, and constants
+  deprecated in 4.49.0 have been removed.  Before upgrading to Sequel
+  5.0.0, upgrade to 4.49.0 and fix all deprecation warnings.
+
+* Support for ruby 1.8.7 has been dropped, the minimum ruby version is
+  now 1.9.2.
+
+* The {before,after,around}_validation hooks are now always called
+  when saving, even if the validate: false option is used.  This
+  allows you to use the before_validation hook to make changes
+  to the model instance that are required before validation and
+  before saving even if not validating.
+
+* Getting column values for newly created model instances after
+  insertion now happens before after_create is called, instead of
+  after.
+
+* Sequel now immediately attempts to the connect to the database
+  when a Database instance is created, in order to fail fast if the
+  connection parameters are invalid.
+
+* The validates_unique method in the validation_helpers plugin
+  now only checks for uniqueness by default if the record is new or
+  one of the related columns has been modified by default.
+
+* Database schema modification methods and schema generator methods
+  now return nil instead of some internal value.
+
+* Many cases where Sequel used Kernel#send internally have been
+  switched to Kernel#public_send so they only call public methods.
+
+* Model association hooks are now nil instead of empty arrays by
+  default.
+
+* Internal uses of instance_eval with a block have been changed to
+  instance_exec.  This allows them to be used with lambdas that
+  take no arguments.
+
+* Most internal constants are now frozen, unless there is a
+  requirement that they be modified at runtime.
+  
+* The Model @was_new instance variable is now no longer set when
+  saving new model instances.
+
+* The private Sequel::Postgres::PGArray::Parser#new_entry_buffer
+  method in the pg_array extension has been removed.
+
+* Modifying Model.input_transformer_order in the input_transformer
+  plugin no longer has an effect.
+
+= New Features
+
+* Database#add_index :if_not_exists option is now supported on
+  PostgreSQL 9.5+.
+
+* SQL::Subscript#expression has been added to retrieve the
+  expression that is subscripted.
+
+= Other Improvements
+
+* Threaded connection pools no longer block while new connections
+  are being made.  Previously, attempting to establish a new
+  connection blocked all connection pool activity until the new
+  connection was made.
+
+* Many minor performance improvements have been made.
+
+* The class_table_inheritance plugin now raises an error during
+  Model#update if a query does not modify a single row, just as
+  the default Model#update does.
+
+* ConnectionPool#size is now thread-safe in both threaded
+  connection pools. Internal callers that already have the
+  connection pool mutex should switch to using #_size (a new
+  private method).
+
+* Registration of new serialization formats in the serialization
+  plugin is now thread-safe.
+
+* If transactional schema modifications are not supported, a
+  savepoint will not automatically be created when adding
+  indexes for new tables inside transactions.  This fixes issues
+  when making schema changes inside transactions on MySQL.
+
+* Attempting to create a prepared statement using a dataset that
+  uses a delayed evaluation now raises an error, because the
+  prepared statement would not respect the delayed evaluation.
+
+* The bin/sequel -M option now uses base 10.  Previously, it
+  used the Kernel#Integer default, which was base 8 if there was
+  a preceding 0.
+
+= Deprecated Features
+
+These deprecated features will be removed in Sequel 5.1.0.
+
+* Model.allowed_columns in the base plugin is now deprecated. Use
+  the whitelist_security plugin if you want to call it.
+
+* Model use_after_commit_rollback class and instance accessors are
+  now deprecated.
+
+* Defining the Model#_before_validation method is now deprecated.
+  You can change to using before_validation.
+
+* The private Model.plugin_module_defined? method is now deprecated.

data/doc/release_notes/5.1.0.txt

@@ -0,0 +1,31 @@
+= Improvements
+
+* Database#copy_into in the jdbc/postgresql adapter now works
+  correctly when using multibyte characters in strings.
+
+* The alter_table add_foreign_key method is now reversible when the
+  :foreign_key_constraint_name option is used.
+
+* The jdbc/h2 and jdbc/hsqldb adapters now respect the
+  :foreign_key_constraint_name option.
+
+* Calling Model.freeze on an already frozen model no longer raises
+  an error.
+
+* An unnecessary database query is now avoided when loading the
+  pg_inet extension when the pg_array extension is already loaded.
+
+* A better exception message is now used when migrating with an
+  empty migration directory.
+
+= Backwards Compatibility
+
+* Model.allowed_columns has been removed. Use the whitelist_security
+  plugin if you want to call it.
+
+* Model use_after_commit_rollback class and instance accessors have
+  been removed.
+
+* Support for the Model#_before_validation method has been removed.
+
+* The private Model.plugin_module_defined? method has been removed.

data/doc/release_notes/5.10.0.txt

@@ -0,0 +1,84 @@
+= New Features
+
+* Ruby 2.6+ endless ranges are now supported as condition specifier
+  values, using a >= operator for them:
+
+    DB[:t].where(c: 1...)
+    # SELECT * FROM t WHERE (c >= 1)
+
+* Ruby 2.6+ endless ranges are now supported in the pg_range
+  extension:
+
+    DB[:t].where(id: 1).update(r: 1...)
+    # UPDATE t SET r = '[1,)' WHERE (id = 1)
+
+* The :include option when creating indexes is now supported on
+  PostgreSQL 11, specifying additional columns to include in the index
+  without indexing them.  This is useful to allow index only scans in
+  additional cases.
+
+* The :tablespace option is now supported when creating tables,
+  indexes, and materialized views on PostgreSQL.
+
+* The list plugin now supports a :top option, which can be used to
+  specify the top of the list.  The default value for the top of the
+  list is 1, but using this option you can make the top of the list be
+  0.
+
+= Other Improvements
+
+* In the pg_array_associations plugin, filtering by associations for
+  many_to_pg_array associations now works correctly on PostgreSQL 11.
+  Previously it did not work on PostgreSQL 11 due to new restrictions
+  on using set returning functions in the the SELECT list.
+
+* When setting the value of a column to the same value the column
+  already has, for a new model object that has not yet been persisted,
+  where the column is used as the foreign key for at least one
+  many_to_one association, do not clear any related associations from
+  the associations cache.
+
+* In the pg_array extension, if there are separate conversion procs for
+  timetz and time types, the conversion proc for the timetz[] type now
+  correctly uses the conversion proc for the timetz type to convert
+  scalar values, instead of the conversion proc for the time type.
+
+* Empty arrays and hashes are now correctly handled in
+  Dataset#{first,where_all,where_each,where_single_value} when a
+  cached placeholder literalizer is used.
+
+* In the tree plugin, Model#{ancestors,descendants,self_and_siblings}
+  now work correctly when custom parent/children association names
+  are used.
+
+* The inner loop of the postgres adapter row fetching code is now
+  2-3% faster.
+
+* When using the postgres adapter with pg-0.18+, set a
+  type_map_for_queries for the connection to allow it to handle input
+  type casts for Integer, Float, TrueClass, and FalseClass values
+  without allocating strings.
+
+* SQLTime.parse (and therefore Sequel.string_to_time) now respects the
+  SQLTime.date and Sequel.application_timezone settings.
+
+* The jdbc/postgresql adapter now correctly parses timetz types.
+
+* On JRuby 9.2.0.0, when handling BC timestamps without timezones in
+  the pg_extended_date_support extension, assume local time and not
+  UTC time if the database timezone is not specified and
+  Sequel.datetime_class is Time.
+
+* Errors indicating that a MySQL database is in read-only mode are
+  now treated as disconnect errors in the mysql and mysql2 adapters,
+  for better behavior in failover scenarios.
+
+* Sequel::Model datasets now support the use of IN/NOT IN operators
+  where the second argument for the operator (the right hand side) is
+  a set returning function.  Previously, the Sequel::Model code
+  assumed the right hand side of an IN/NOT IN operator was a datasets
+  or array, since those are the only values where Sequel will
+  automatically create such an operator.
+
+* Sequel no longer loads the strscan library in the pg_array extension
+  if it is not necessary because the parser from sequel_pg is used.

data/doc/release_notes/5.11.0.txt

@@ -0,0 +1,83 @@
+= New Features
+
+* Sequel now supports more window frame specification types when
+  using window functions.  You can now provide the window frame
+  specification as a hash, and Sequel will format the correct
+  SQL.  Specifically, this adds support for RANGE and GROUPS,
+  numeric offsets, and EXCLUDE on a database that supports it
+  (e.g. PostgreSQL 11+).  Examples:
+
+    DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3,
+      :frame=>{:type=>:range, :start=>1, :end=>1})}
+    # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3
+    # RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM albums
+
+    DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3,
+      :frame=>{:type=>:groups, :start=>[2, :preceding], :end=>[1, :preceding]})}
+    # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3
+    # GROUPS BETWEEN 2 PRECEDING AND 1 PRECEDING) FROM albums
+
+    DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3,
+      :frame=>{:type=>:range, :start=>:preceding, :exclude=>:current})}
+    # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3
+    # RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM albums
+
+* The SQLite 3.24+ ON CONFLICT clause to INSERT is now supported.
+  This support is very similar to the PostgreSQL support for the
+  same feature, also known as  UPSERT (UPDATE if the row already
+  exists, INSERT if it does not).  This support is different than
+  the previous support for INSERT ON CONFLICT REPLACE (also known as
+  INSERT OR REPLACE), but it uses the same method name in order to
+  be compatible with the PostgreSQL support.  The new syntax requires
+  passing a hash to Dataset#insert_conflict.  Examples:
+
+    DB[:table].insert_conflict({}).insert(a: 1, b: 2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT DO NOTHING
+ 
+    DB[:table].insert_conflict(target: :a).insert(a: 1, b: 2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT (a) DO NOTHING
+ 
+    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
+ 
+    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
+ 
+    DB[:table].insert_conflict(target: :a,
+      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 (a)
+    # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
+
+* Dataset#window for the WINDOW clause has been moved from the
+  PostgreSQL-specific support to core, and has been enabled on
+  MySQL 8+ and SQLAnywhere.  This allows you to specify a shared
+  window specification in a query, which can be used by multiple
+  window functions.
+
+= Other Improvements
+
+* When using the static_cache plugin, Model.first when called without
+  a block and without arguments or with a single Integer argument now
+  uses the cached values instead of issuing a query.
+
+* Using set_column_default with a nil value now correctly removes an
+  existing default value on MySQL when the column is NOT NULL.
+
+* Window function support has been enabled on SQLAnywhere, since it
+  works correctly.
+
+* Dumping schema for numeric/decimal columns with default values
+  now works correctly.  This was broken starting in Sequel 5.9.0
+  due to changes to use BigDecimal() instead of BigDecimal.new().
+
+* The jdbc/sqlserver adapter now works correctly on JRuby 9.2+.
+
+* An additional check constraint violation failure message is now
+  recognized on SQLite.

data/doc/release_notes/5.12.0.txt

@@ -0,0 +1,141 @@
+= New Features
+
+* An eager_graph_eager plugin has been added, which allows you to
+  chain eager loads using separate queries to an existing dataset that
+  uses eager_graph.  Given the following model associations:
+
+    Band.one_to_many :albums
+    Album.one_to_many :tracks
+
+  Let's say you wanted to return bands ordered by album name, and
+  eagerly load those albums, you can do that using:
+
+    Band.eager_graph(:albums).order{albums[:name]}
+
+  Let's say you also wanted to eagerly load the tracks for each album.
+  You could just add them to the eager_graph call:
+
+    Band.eager_graph(albums: :tracks).order{albums[:name]}
+
+  However, the bloats the result set, and you aren't ordering by the
+  track information, so a join is not required.  The eager_graph_eager
+  plugin allows you to specify that the tracks be eagerly loaded in a
+  separate query after the eager_graph load of albums:
+
+    Band.eager_graph(:albums).
+      eager_graph_eager([:albums], :tracks).
+      order{albums[:name]}
+
+  eager_graph_eager's first argument is a dependency chain, specified
+  as an array of symbols.  This specifies the point at which to
+  perform the eager load. The remaining arguments are arguments that
+  could be passed to Dataset#eager to specify what dependent
+  associations should be loaded at that point.
+
+* A caller_logging Database extension has been added, which logs
+  caller information before queries, filtering out the internal
+  Sequel callers.  Example:
+
+    DB.extension :caller_logging
+    DB[:table].first
+    # Logger:
+    # (0.000041s) (source: /path/to/app/foo/t.rb:12 in `get_first`)
+    # SELECT * FROM table LIMIT 1
+
+  You can further filter the caller lines by setting
+  Database#caller_logging_ignore to a regexp of additional caller
+  lines to ignore.  This is useful if you have specific methods or
+  internal extensions/plugins that you would also like to ignore as
+  they obscure the code actually making the request.
+ 
+    DB.caller_logging_ignore = %r{/path/to/app/lib/plugins}
+ 
+  You can also format the caller before it is placed in the logger,
+  using caller_logging_formatter:
+ 
+    DB.caller_logging_formatter = lambda do |caller|
+      "(#{caller.sub(/\A\/path\/to\/app\//, '')})"
+    end
+    DB[:table].first
+    # Logger:
+    # (0.000041s) (foo/t.rb:12 in `get_first`) SELECT * FROM table LIMIT 1
+ 
+* Database#call_procedure has been added to the postgres adapter, and
+  is usable on PostgreSQL 11+ for calling procedures created with
+  CREATE PROCEDURE.
+
+    DB.call_procedure(:foo, 1, "bar")
+    # CALL foo(1, 'bar')
+
+  This method will return a hash of results if the procedure returns
+  a result, or nil if it does not return a result.
+
+= Other Improvements
+
+* It is now possible to use Dataset#eager_graph in an eager load
+  callback for associations that use join tables.  This allows you
+  to eager load some associations using separate queries and other
+  associations using joins.  For example:
+
+    Band.eager(:albums=>proc{|ds| ds.eager_graph(:tracks)})
+
+  Will load the bands in one query, and load the albums and tracks
+  in a separate query using a join.  Previously, this construction
+  worked only for associations that did not use join tables.  It now
+  works for associations that use join tables, as long as existing
+  selected columns are not removed inside the callback.
+
+* The tactical_eager_loading plugin now handles automatic eager
+  loading for associated objects that were created during the
+  load of dataset that uses eager_graph.  When using the plugin,
+  the following code will now only execute 2 queries, instead of
+  issuing a separate query for each album to get the tracks for
+  the album.
+
+    artists = Artist.eager_graph(:albums).all
+    artists.each do |artist|
+      artist.albums.each do |album|
+        album.tracks
+      end
+    end
+
+* Calling Dataset#graph with a dataset with existing selections where
+  the column aliases cannot be determined automatically now works
+  correctly by using a subselect.  Previously, attempting to do this
+  would raise an exception.  This allows the following code to work:
+
+    DB[:table].select_all(:table).select_append(expr).graph(...)
+
+* Datasets now cache the EagerGraphLoader object that is generated to
+  convert arrays of hashes into an object graph, so that subsequent
+  eager loads on the same dataset do not need to recompute the same
+  information.  Most EagerGraphLoader internal state is now frozen to
+  prevent unintentional modification.
+
+* Sequel.extension now loads files from gems.  Previously, it used
+  Kernel.require, which does not load files from gems.
+
+* Adapters that emulate prepared statements using literalization now
+  use a placeholder literalizer and should execute significantly
+  faster.  More prepared statement internal metadata is now frozen
+  to prevent unintentional modification.
+
+* Dataset#intersect, #except, and #nowait are now supported on MariaDB
+  10.3+.
+
+* The constraint_validations extension now respects the
+  constraint_validations_table setting when adding metadata for the
+  constraint validations.
+
+* In the oracle adapter, the clob prepared statement argument type is
+  now mapped to the OCI8::CLOB class, allowing the use of Oracle
+  procedures with clob output parameters.
+
+* The Model.load_cache method in the static_cache plugin is now public.
+
+= Backwards Compatibility
+
+* The private Dataset#prepared_arg? method has been removed.  It is no
+  longer necessary after the refactoring to the prepared statement
+  code.  External adapters that currently call the method should be
+  updated to no longer call the method.

data/doc/release_notes/5.13.0.txt

@@ -0,0 +1,27 @@
+= New Features
+
+* A constant_sql_override Database extension has been added, allowing
+  for overriding the SQL used by constants such as
+  Sequel::CURRENT_TIMESTAMP.  This can be used to force
+  CURRENT_TIMESTAMP to be literalized at a particular time zone:
+
+    DB.extension :constant_sql_override
+    DB.set_constant_sql(Sequel::CURRENT_TIMESTAMP,
+      "CURRENT_TIMESTAMP AT TIME ZONE 'UTC'")
+
+* Prepared statements now support the :single_value type, which
+  returns the first column value in the dataset.
+
+    prep_stmt = DB[:table].select(:column).prepare(:single_value, :ps)
+    prep_stmt.call
+    # PREPARE ps AS SELECT column FROM table LIMIT 1;
+    # EXECUTE ps;
+    # => 42
+
+= Other Improvements
+
+* Dataset#from_self will no longer use a cached dataset if any options
+  are given, as that can result in incorrect behavior.
+
+* Model.all in the static_cache plugin now accepts a block, mirroring
+  the API when the static_cache plugin is not used.

data/doc/release_notes/5.14.0.txt

@@ -0,0 +1,63 @@
+= New Features
+
+* The :nulls option when creating ordered expressions is now supported
+  on all databases that Sequel ships support for.  For databases that
+  do not support NULLS FIRST/NULLS LAST, support is emulated.
+
+    ds.order(Sequel.asc(:name, :nulls=>:last))
+    # When emulated:
+    # ORDER BY (CASE WHEN (name IS NULL) THEN 2 ELSE 1 END), name ASC
+
+* Model#pk_equal? has been added as a more descriptive name for
+  Model#===.  Model#=== is now an alias of Model#pk_equal?.
+
+* The roots and roots_dataset class methods in the tree plugin are now
+  also available as dataset methods.
+
+= Other Improvements
+
+* Inverting expressions using the ANY/SOME/ALL SQL operators now works
+  correctly:
+
+    # Sequel <5.14.0
+    Sequel.~(:a=>Sequel.function(:any, :x))
+    # "(a != any(x))"
+
+    # Sequel >=5.14.0
+    Sequel.~(:a=>Sequel.function(:any, :x))
+    # "NOT (a = any(x))"
+
+  Sequel has always tried to push inversion down to create SQL that is
+  easier to reason about.  However, inversion cannot be pushed down if
+  an ANY/SOME/ALL SQL operator is used, because that is a different
+  type of operation that just happens to use the same syntax.  Sequel
+  now avoids inversion push down for boolean operators where the
+  right hand side is an SQL::Function, LiteralString, or
+  SQL::PlaceholderLiteralString.
+
+* When creating a boolean expression from a hash or array of pairs, if
+  the right hand side is an unfrozen array and string, use a frozen
+  copy in the expression, so that mutating the array or string
+  argument later does not affect the expression.
+
+* When using the defaults_setter plugin with the :cache option, do not
+  cache values for columns without parseable defaults.  If the default
+  value exists but is not parseable, caching such values could result
+  in incorrect behavior if the model instance is saved later.
+
+* For models with composite primary keys, Model#=== now returns false
+  if any primary key value is nil, mirroring the behavior for the
+  scalar primary key case.
+
+* Model datasets no longer cache SQL if they include a subquery that
+  cannot cache SQL.
+
+* The SQL used for constraints in the constraint_validations
+  extension when the :allow_nil option is used is now clearer and
+  easier to understand.
+
+* The postgres adapter no longer specifies a default port when using
+  the pg driver, in order to work with configurations where the
+  :service option is used in the :driver_options hash.  The pg driver
+  defaults to port 5432 if no port is given, so this should not affect
+  backwards compatibility.

data/doc/release_notes/5.15.0.txt

@@ -0,0 +1,39 @@
+= New Features
+
+* A :qualify_tables option has been added to the
+  class_table_inheritance plugin, which will automatically qualify
+  subclass tables with the same qualifier as the superclass table
+  if the superclass table is qualified.
+
+* Model#save_validation_on_next_save! has been added, which skips all
+  validation on the next save to the object, including the running
+  of validation related hooks.  This method is designed for use only
+  when Model#valid? is called on the object before saving, to avoid
+  running validations on the object twice.  This method takes
+  precedence even over an explicit validate: true option passed to
+  Model#save, and as such should be used with care.
+
+* The postgres adapter now supports a :conn_str Database option to
+  use a PostgreSQL connection string (e.g. "host=foo port=2442") when
+  connecting.  This option has preference over other connection
+  related options if it is present.
+
+= Other Improvements
+
+* If a foreign key for a model object is changed from a nil value to
+  a non-nil value, any cached associated objects related to the
+  foreign key are no longer removed.  Such associated objects could
+  only be set manually, and if they have been set manually, it is
+  probably not a good idea to remove them automatically.
+
+* When using the nested_attributes plugin, new *_to_many associated
+  objects are not validated twice when saving.
+
+* The default table alias when using the class_table_inheritance
+  plugin now correctly handles qualified tables.
+
+* A theoretical thread safety issue when assigning connections
+  in the threaded connection pools has been fixed.
+
+* Renaming columns is now supported without emulation when using
+  SQLite 3.25+.