sequel 4.26.0 → 5.37.0

data/doc/release_notes/3.29.0.txt

@@ -1,459 +0,0 @@
-= New Adapter Support
-
-* Sequel now has much better support for Oracle, both in the
-  ruby-oci8-based oracle adapter and in the jdbc/oracle adapter.
-
-* Sequel now has much better support for connecting to HSQLDB
-  using the jdbc adapter.  This support does not work correctly
-  with the jdbc-hsqldb gem, since the version it uses is too
-  old.  You'll need to load the .jar file manually until the
-  gem is updated.
-
-* Sequel now has much better support for connecting to Apache
-  Derby databases using the jdbc adapter.  This works with
-  the jdbc-derby gem, but it's recommend you grab an updated
-  .jar file as the jdbc-derby gem doesn't currently support
-  truncate or booleans.
-
-* The db2 adapter has had most of the remaining issues fixed,
-  and can now run Sequel's test suite cleanly.  It's still
-  recommended that users switch to the ibmdb adapter if they
-  are connecting to DB2.
-
-* A mock adapter has been added which provides a mock Database
-  object that allows you to easily set the returned rows, the
-  number of rows modified by update/delete, and the
-  autogenerating primary key integer for insert.  It also allows
-  you to set specific columns in the dataset when retrieving
-  rows.  The specs were full of partial implementations of
-  mock adapters, this mock adapter is much more complete and
-  offers full support for mocking transactions and database
-  sharding.  Example:
-
-    DB = Sequel.mock(:fetch=>{:id=>1}, :numrows=>2, :autoid=>3)
-    DB[:items].all            # => [{:id => 1}]
-    DB[:items].insert         # => 3
-    DB[:items].insert         # => 4
-    DB[:items].delete         # => 2
-    DB[:items].update(:id=>2) # => 2
-    DB.sqls # => ['SELECT ...', 'INSERT ...', ...]
-
-  In addition to being useful in the specs, the mock adapter is
-  also used if you use bin/sequel without a database argument,
-  which makes it much easier to play around with Sequel on the
-  command line without being tied to a real database.
-
-= New Transaction Features
-
-* Database after_commit and after_rollback hooks have been added,
-  allowing you to set procs that are called after the currently-
-  in-effect transaction commits or rolls back.  If the Database
-  is not currently in a transaction, the after_commit proc is
-  called immediately and the after_rollback proc is ignored.
-
-* Model after_commit, after_rollback, after_destroy_commit, and
-  after_destroy_rollback hooks have been added that use the new
-  Database after_commit/after_rollback hook to execute code after
-  commit or rollback.
-
-* Database#transaction now supports a :rollback => :reraise option
-  to reraise any Sequel::Rollback exceptions raised by the block.
-
-* Database#transaction now supports a :rollback => :always option
-  to always rollback the transaction, which is mostly useful when
-  using transaction-based testing.
-
-* Sequel.transaction has been added, allowing you to run
-  simultaneous transactions on multiple Database objects:
-
-    Sequel.transaction([DB1, DB2]){...}
-    # similar to:
-    DB1.transaction{DB2.transaction{...}}
-
-  You can combine this with the :rollback => :always option to
-  easily use multiple databases in the same test suite and make sure
-  that changes are rolled back on all of them.
-
-* Database#in_transaction? has been added so that users can detect
-  whether the code is currently inside a transaction.
-
-* The generic JDBC transaction support, used by 6 of Sequel's jdbc
-  subapters, now supports savepoints if the underlying JDBC driver
-  supports savepoints.
-
-= Other New Features
-
-* A dataset_associations plugin has been added, allowing datasets
-  to call association methods, which return datasets of rows in
-  the associated table that are associated to rows in the current
-  dataset.
-
-    # Dataset of tracks from albums with name < 'M'
-    # by artists with name > 'M'
-
-    Artist.filter(:name > 'M').albums.filter(:name < 'M').tracks
-
-    # SELECT * FROM tracks
-    # WHERE (tracks.album_id IN (
-    #   SELECT albums.id FROM albums
-    #   WHERE ((albums.artist_id IN (
-    #     SELECT artists.id FROM artists
-    #     WHERE (name > 'M')))
-    #    AND (name < 'M'))))
-
-* Database#extend_datasets has been added, allowing you to do the
-  equivalent of extending all of the database's future datasets
-  with a module.  For performance, it creates an anonymous
-  subclass of the current dataset class and includes a module in
-  it, and uses the subclass to create future datasets.
-
-  Using this feature allows you to override any dataset method
-  and call super, similar to how Sequel::Model plugins work. The
-  method takes either a module:
-
-    Sequel.extension :columns_introspection
-    DB.extend_datasets(Sequel::ColumnsIntrospection)
-
-  or a block that it uses to create an anonymous module:
-
-    DB.extend_datasets do
-      # Always select from table.* instead of *
-      def from(*tables)
-        ds = super
-        if !@opts[:select] || @opts[:select].empty?
-          ds = ds.select_all(*tables)
-        end
-        ds
-      end
-    end
-
-* Database#<< and Dataset#<< now return self, which allow them
-  to be used in chaining:
-
-    DB << "UPDATE foo SET bar_id = NULL" << "DROP TABLE bars"
-    DB[:foo] << {:bar_id=>0} << DB[:bars].select(:id)
-
-* A Database#timezone accessor has been added, allowing you to
-  override Sequel.database_timezone on a per-Database basis, which
-  allows you to use two separate Database objects in the same
-  process that have different timezones.
-
-* You can now modify the type conversion procs on a per-Database
-  basis when using the mysql, sqlite, and ibmdb adapters, by
-  modifying the hash returned by Database#conversion_procs.
-
-* Model.dataset_module now accepts a Module instance as an argument,
-  and extends the model's dataset with that module.
-
-* When using the postgres adapter with the pg driver, you can now
-  use Database#listen to wait for notifications.  All adapters that
-  connect to postgres now support Database#notify to send
-  notifications:
-
-    # process 1
-    DB.listen('foo') do |ev, pid, payload|
-      ev # => 'foo'
-      notify_pid # => some Integer
-      payload # => 'bar'
-    end
-
-    # process 2
-    DB.notify('foo', :payload=>'bar')
-
-* many_to_one associations now have a :qualify option that can be set
-  to false to not qualify the primary key when loading the
-  association.  This shouldn't be necessary to use in most cases, but
-  in some cases qualifying a primary key breaks certain queries (e.g.
-  using JOIN USING on the same column on Oracle).
-
-* Database#schema can now take a dataset as an argument if it just
-  selects from a single table.  If a dataset is provided, the
-  schema parsing will use that dataset's identifier_input_method
-  and identifier_output_method for the parsing, instead of the
-  database's default.  This makes it possible for Model classes
-  to correctly get the table schema if they use a dataset whose
-  identifier_(input|output)_method differs from the database
-  default.
-
-* On databases that support common table expressions (CTEs) but do
-  not support CTE usage in subselects, Sequel now emulates support
-  by moving CTEs from the subselect to the main select when using
-  the Dataset from, from_self, with, with_recursive, union,
-  intersect, and except methods.
-
-* The bitwise compliment operator is now emulated on H2.
-
-* You can now set the convert_tinyint_to_bool setting on a
-  per-Database basis in the mysql and mysql2 adapters.
-
-* You can now set the convert_invalid_date_time setting on a
-  per-Database basis in the mysql adapter.
-
-* Database instances now have a dataset_class accessor that allows
-  you to set which class is used when creating datasets.  This is
-  mostly used to implement the extend_datasets support, but it
-  could be useful for other purposes.
-
-* Dataset#unused_table_alias now accepts an optional 2nd argument,
-  which should be an array of additional symbols that should be
-  considered as already used.
-
-* Dataset#requires_placeholder_type_specifiers? has been added to
-  check if the dataset requires you use type specifiers for
-  bound variable placeholders.
-
-  The prepared_statements plugin now checks this setting and works
-  correctly on adapters that set it to true, such as oracle.
-
-* Dataset#recursive_cte_requires_column_aliases? has been added
-  to check if you must provide a column list for a recursive CTE.
-
-  The rcte_tree plugin now checks this setting an works correctly
-  on databases that set it to true, such as Oracle and HSQLDB.
-
-= Performance Improvements
-
-* Numerous optimizations were made to loading model objects from
-  the database, resulting in a 7-16% speedup.
-
-  Model.call was added, and now .load is just an alias for .call.
-  This allows you to make the model dataset's row_proc the model
-  itself, instead of needing a separate block, which improves
-  performance.
-
-  While Model.load used to call .new (and therefore #initialize),
-  Model.call uses .allocate/#set_values/#after_initialize for speed.
-  This saves a method call or two, and skips setting the @new
-  instance variable.
-
-* Dataset#map, #to_hash, #select_map, #select_order_map, and
-  #select_hash are now faster if any of the provided arguments are
-  an array of symbols.
-
-* The Model.[] optimization is now applied in more cases.
-
-= Other Improvements
-
-* Sequel now creates accessor methods for all columns in a model's
-  table, even if the dataset doesn't select the columns.  This has
-  been the specified behavior for a while, but the spec was broken.
-  This allows you do to:
-
-    Model.dataset = DB[:table].select(:column1, :column2)
-    Model.select_more(:column3).first.column3
-
-* Model.def_dataset_method now correctly handles method names that
-  can't be used directly (such as method names with spaces).  This
-  isn't so the method can be used with arbitrary user input, but
-  it will allow safe creation of dataset methods that are derived
-  from column names, which could contain spaces.
-
-* Model.def_dataset_method no longer overrides private model
-  methods.
-
-* The optimization that Model.[] uses now works correctly if the
-  model's dataset uses a different identifier_input_method than
-  the database.
-
-* Sharding is supported correctly by default for the transactions
-  used by model objects.  Previously, you had to use the sharding
-  plugin to make sure the same shard was used for transactions as
-  for the insert/update/delete statements.
-
-* Sequel now fully supports using an aliased table for the
-  :join_table option of a many_to_many association.  The only real
-  use case for an aliased :join_table option is when the join table
-  is the same as the associated model table.
-
-* A bug when eagerly loading a many_through_many association with
-  composite keys where one of the join tables requires an alias
-  has been fixed.
-
-* Sequel's transaction internals have had substantial improvments.
-  You can now open up simultaneous transactions on two separate
-  shards of the same Database object in the same thread.  The new
-  design allows for future support of connection pools that aren't
-  based on threads.  Sequel no longer abuses thread-local variables
-  to store savepoint state.
-
-* Dataset#select_map and #select_order_map now return an array of
-  single element arrays if given an array with a single entry as
-  an argument.  Previously, they returned an array of values, which
-  wasn't consistent.
-
-* Sequel's emulation of bitwise operators with more than 2 arguments
-  now works on all adapters that use the emulation.  The emulation
-  was broken in 3.28.0 when more than 2 arguments were used on H2,
-  DB2, Microsoft SQL Server, PostgreSQL, and SQLite.
-
-* Dataset#columns now correctly handles the emulated offset support
-  used on DB2, Oracle, and Microsoft SQL Server when using the
-  jdbc, odbc, ado, and dbi adapters.  Previously, Dataet#columns
-  could contain the row number column, which wasn't in the
-  hashes yielded by Dataset#each.
-
-* Sequel can now parse primary key information on Microsoft SQL
-  Server.  Previously, the only adapter that supported this was the
-  jdbc adapter, which uses the generic JDBC support.  The shared
-  mssql adapter now supports parsing the information directly from
-  the database system tables.  This means that if you are using
-  Model objects with a Microsoft SQL Server database using the
-  tinytds, odbc, or ado adapters, the model primary key
-  information will be set automatically.
-
-* Sequel's prepared statement support no longer defines singleton
-  methods on the prepared statement objects.
-
-* StringMethods#like is now case sensitive on SQLite and Microsoft
-  SQL Server, making it more similar to other databases.
-
-* Sequel now works around an SQLite column naming bug if you select
-  columns qualified with the alias of a subselect without providing
-  an alias for the column itself.
-
-* Sequel now handles more bound variable types when using bound
-  variables outside of prepared statements on SQLite.
-
-* Sequel now works around a bug in certain versions of the
-  JDBC/SQLite driver when emulating alter table support for
-  operations such as drop_column.
-
-* Sequel now emulates the add_constraint and drop_constraint
-  alter table operations on SQLite, though the emulation has
-  issues.
-
-* Sequel now correctly handles composite primary keys when
-  emulating alter_table operations on SQLite.
-
-* Sequel now applies the correct PRAGMA statements by default when
-  connecting to SQLite via the amalgalite and swift adapters.
-
-* Sequel now supports using savepoints inside prepared transactions
-  on MySQL.
-
-* Sequel now closes JDBC ResultSet objects as soon as it is done
-  using them, leading to potentially lower memory usage in the JDBC
-  adapter, and fixes issues if you try to drop a table before
-  GC has collected a related ResultSet.
-
-* Sequel can now correctly insert all default values into a table
-  on DB2.  Before, this didn't work correctly if the table had more
-  than one column.
-
-* Another type of disconnection error is now recognized in the
-  mysql2 adapter.
-
-* Sequel now uses better error messages if you attempt to execute a
-  prepared statement without a name using the postgres, mysql, and
-  mysql2 adapters.
-
-* Some small fixes have been made that allow Sequel to run better
-  when $SAFE=1.  However, Sequel is not officially supported using
-  $SAFE > 0, so there could be many issues remaining.
-
-* Sequel's core and model specs were cleaned up by using the mock
-  adapter to eliminate a lot of redundant code.
-
-* Sequel's integration tests were sped up considerably, halving
-  the execution time on some adapters.
-
-= Backwards Compatibility
-
-* Because Model.load is now an alias for .call, plugins should no
-  longer override load.  Instead, they should override .call.
-
-* Loading model objects from the database no longer calls
-  Model#initialize.  Instead, it calls Model.allocate,
-  Model#set_values, and Model#after_initialize.  So if you were
-  overriding #initialize and expecting the changes to affect model
-  objects loaded from the database, you need to change your code.
-
-  Additionally, @new is no longer set to false for objects retieved
-  from the database, since setting it to false hurts performance.
-  Model#new? still returns true or false, so this only affects you
-  if you are checking the instance variables directly.
-
-* Dataset#<< no longer returns the autogenerated primary key for the
-  inserted row.  As mentioned above, it now returns self to allow for
-  chaining.  If you were previously relying on the return value,
-  switch from #<< to #insert.
-
-* Dataset#map no longer calls the row_proc if given an argument, and
-  Dataset#to_hash no longer calls the row_proc if given two arguments.
-  This should only affect your code if you were using a row_proc that
-  modified the content of the hash (e.g. Model#after_initialize). If
-  you were relying on the old behavior, switch:
-
-    dataset.map(:foo)
-    # to
-    dataset.map{|r| r[:foo]}
-
-    dataset.to_hash(:foo, :bar)
-    # to
-    h = {}
-    dataset.each{|r| h[r[:foo]] = r[:bar]}
-    h
-
-* Model classes now need to have a dataset before you can define
-  associations on them.
-
-* Model classes now pass their dataset to Database#schema, instead of
-  their table name.
-
-* The :eager_block association option (which defaults to the
-  association's block argument) is now called before the :eager_graph
-  association option has been applied, instead of after.
-
-* The many_to_many association reflection :qualified_right_key entry
-  is now a method named qualified_right_key.  Switch any
-  code using association_reflection[:qualified_right_key] to use
-  association_reflection.qualified_right_key.
-
-* If you are using like on SQLite and Microsoft SQL Server and want
-  it to be case insensitive, switch to using ilike:
-
-    # Case sensitive
-    DB[:foos].where(:name.like('bar%'))
-    # Case insensitive
-    DB[:foos].where(:name.ilike('bar%'))    
-
-  Sequel now sets the case_sensitive_like PRAGMA to true by default
-  on SQLite.  To set it to false instead, pass the
-  :case_sensitive_like=>false option to the database when creating it.
-
-* Sequel's alter table emulation on SQLite now renames the current
-  table then populates the replacement table, instead of
-  populating the replacement table at a temporary name, dropping
-  the current table, and then renaming the replacement table.
-
-* The strings 'n' and 'no' (case insensitive) when typecasted to
-  boolean are now considered false values instead of true.
-
-* The transaction internals had extensive changes, if you have any
-  code that depended on the transaction internals, it will probably
-  require changes.
-
-* Using the Sequel::MySQL module settings for convert_tinyint_to_bool
-  and convert_invalid_date_time now only affects future Database
-  objects.  You should switch to using the per-Database methods
-  if you are currently using the Sequel::MySQL module methods.
-
-* The customized transaction support in the do (DataObjects) adapter
-  was removed.  All three subadapters (postgres, mysql, sqlite) of
-  the do adapter implement their own transaction support, so this
-  should have no effect unless you were using the do adapter with
-  a different database type.
-
-* The oracle support changed dramatically, so if you were relying
-  on the internals of the oracle support, you should take extra
-  care when upgrading.
-
-= Advance Notice
-
-* The next release of Sequel will contain significant changes to
-  how a dataset is literalized into an SQL string.  If you have
-  a custom plugin, extension, or adapter that overrides a
-  method containing "literal", "sql", or "quote", or you make
-  other modifications or extensions to how Sequel currently
-  literalizes datasets to SQL, your code will likely need to
-  be modified to support the next release.