sequel 4.36.0 → 5.61.0

data/doc/release_notes/3.37.0.txt

@@ -1,338 +0,0 @@
-= New Features
-
-* Database#extension and Dataset#extension have been added and
-  make it much easier to use extensions that just define modules,
-  where you previously had to manually extend a Database or
-  Dataset object with the module to get the extension's behavior.
-  These methods operate similarly to model plugins, where you just
-  specify the extension symbol, except that you can specify multiple
-  extensions at once:
-
-    DB.extension(:pg_array, :pg_hstore)
-
-  For databases, these modify the Database itself (and
-  potentially all of its datasets).  Dataset#extension operates
-  like other dataset methods, returning a modified clone of
-  the dataset with the extension added:
-
-    dataset = dataset.extension(:columns_introspection)
-
-  Dataset#extension! has also been added for modifying the
-  receiver instead of returning a clone.
-
-  Not all extensions are usable by Database#extension or
-  Dataset#extension, the extension has to have specific support
-  for it.  The following extensions support both
-  Database#extension and Dataset#extension:
-
-  * columns_introspection
-  * query_literals
-  * split_array_nil
-
-  The following extensions support just Database#extension:
-
-  * arbitrary_servers
-  * looser_typecasting
-  * pg_array
-  * pg_auto_parameterize
-  * pg_hstore
-  * pg_inet
-  * pg_interval
-  * pg_json
-  * pg_range
-  * pg_statement_cache
-  * server_block
-
-  Any user that was loading these extensions with Sequel.extension
-  and then manually extending objects with the extension's module
-  is encouraged to switch to Database#extension and/or
-  Dataset#extension.
-
-* Dataset join methods now respect a :qualify=>:deep option
-  to do deep qualification of expressions, allowing qualification
-  of subexpressions in the expression tree.  This can allow you
-  to do things like:
-
-     DB[:a].join(:b, {:c.cast(Integer)=>:d.cast(Integer)},
-                 :qualify=>:deep)
-     # SELECT * FROM a INNER JOIN b
-     # ON (CAST(b.c AS INTEGER) = CAST(a.d AS INTEGER))
-
-  For backwards compatibility, by default Sequel will only do
-  automatic qualification if the arguments are simple symbols.
-  This may change in a future version, if automatic qualification
-  of only symbols is desired, switch to using :qualify=>:symbol.
-  
-  You can also choose to do no automatic qualification using the
-  :qualify=>false option.
-
-* All of Sequel's model associations now work with key expressions
-  that are not simple column references, without creating a fully
-  custom association.  So you can create associations where the
-  primary/foreign key values are stored in PostgreSQL array or
-  hstore columns, for example.
-
-* The pg_array extension has now been made more generic, so that it
-  is easy to support array types for any scalar type that is
-  currently supported.  All scalar types that Sequel's postgres
-  adapter supports now have corresponding array types supported in
-  the pg_array extension.  So if you load the pg_array extension and
-  return a date array column, the returned values will be arrays of
-  ruby Date objects.
-
-  Other pg_* extensions that add support for PostgreSQL-specific
-  scalar types now support array versions of those types if the
-  pg_array extension is loaded first.
-
-* A pg_range extension has been added, making it easy to deal
-  with PostgreSQL 9.2+'s range types.  As ruby's Range class does
-  not support all PostgreSQL range type values (such as empty ranges,
-  unbounded ranges, or ranges with an exlusive beginning), range
-  types are returned as instances of Sequel::Postgres::PGRange, which
-  has an API similar to Range.  You can turn a PGRange into a Range
-  using PGRange#to_range, assuming that the range type value does not
-  use features that are incompatible with ruby's Range class.
-
-  The pg_range extension supports all range types supported by
-  default in PostgreSQL 9.2, and makes it easy to support custom
-  range types.
-
-* A pg_range_ops extension has been added, which adds DSL support for
-  PostgreSQL range operators and functions, similar to the
-  pg_array_ops and pg_hstore_ops extensions.
-
-* A pg_interval extension has been added, which makes Sequel return
-  PostgreSQL interval types as instances of ActiveSupport::Duration.
-  This is useful if you want to take the interval value and use it in
-  calculations in ruby (assuming you load the appropriate parts of
-  ActiveSupport).
-
-* A split_array_nil extension has been added, which changes how Sequel
-  compiles IN/NOT IN expressions with arrays with nil values.
-
-    where(:col=>[1, nil])
-    # Default:
-    #   WHERE (col IN (1, NULL))
-    # with split_array_nil extension:
-    #   WHERE ((col IN (1)) OR (col IS NULL))
-
-    exclude(:col=>[1, nil])
-    # Default:
-    #   WHERE (col NOT IN (1, NULL))
-    # with split_array_nil extension:
-    #   WHERE ((col NOT IN (1)) AND (col IS NOT NULL))
-
-* The nested_attributes plugin now allows the :fields option to
-  be a proc, which is called with the associated object and should
-  return an array of allowable fields.
-
-* You can now specify the graph alias base when using eager_graph on
-  a per-call basis.  Previously, it could only be set on a per
-  association basis.  This is helpful if you have multiple
-  associations to the same class, and are cascading the eager graph to
-  dependent associations of that class for both of the associations.
-  Previously, there was no way to manually give descriptive names to
-  the tables in the cascaded associations, but you can now do so
-  by passing the association as an Sequel::SQL::AliasedExpression
-  instance instead of a plain Symbol.  Here's a usage example:
-
-    ds = Game.eager_graph(:winner=>:players.as(:winning_players),
-                          :loser=>:players.as(:losing_players)).
-          where(:winning_players__name=>'A',
-                :losing_players__name=>'B')
-
-* many_through_many associations now differentiate between column
-  references and method references, by supporting the
-  :left_primary_key_column and :right_primary_key_method options that
-  many_to_many associations support.
-
-* Custom :eager_loader procs that accept a single hash argument now
-  have an additional entry passed in the hash, :id_map, which is
-  easier to use than the :key_hash entry (which is still present for
-  backwards compatibility).  Anyone with custom :eager_loader procs is
-  encouraged to switch from using :key_hash to :id_map.
-
-* You can now override the create_table/alter_table schema generators
-  per database/adapter.  This allows for database specific generator
-  subclasses, which have methods for unique features for that
-  database.
-
-* You can now setup exclusion constraints on PostgreSQL using the
-  create_table and alter_table schema generators:
-
-    DB.create_table(:t) do
-      ...
-      exclude([[:col1, '&&'], [:col2, '=']])
-      # EXCLUDE USING gist (col1 WITH &&, col2 WITH =)
-    end
-
-  One common use for exclusion constraints is to make sure that no two
-  rows have overlapping values/ranges/circles.
-
-* When adding foreign key constraints to an existing table on
-  PostgreSQL, you can use the :not_valid option to mark the constraint
-  as not yet valid.  This will make it so that future changes to the
-  table need to respect the foreign key constraint, but existing rows
-  do not.  After cleaning up the existing data, you can then use the
-  alter_table validate_constraint method to mark the constraint as
-  valid.
-
-* An eval_inspect extension has been added that attempts to do
-  do the following for Sequel::SQL::Expression instances:
-
-    eval(obj.inspect) == obj # => true
-
-  There are a lot of cases that this extension does not handle, but
-  it does a decent job in most cases.  This is currently only used
-  internally in a specific case in the schema_dumper extension.
-
-= Other Improvements
-
-* The filter by associations support now respects the method
-  reference vs column reference distinction that other parts of the
-  association code have respected since 3.32.0.
-
-* In the nested_attributes plugin, new one_to_one associated
-  values are saved once instead of twice.  Previously it attempted to
-  save them before they were associated to the current model object,
-  which can violate some validations/constraints.
-
-* When saving an associated object in the one_to_one association
-  setter method, Sequel no longer adds an unnecessary filter
-  condition when nullifying the foreign key for existing rows
-  in the associated table.
-
-* The list plugin's before_create method now calls super, which
-  fixes usage when other plugins that define before_create are loaded
-  before it.
-
-* In the pg_array extension, when typecasting an Array to PGArray,
-  a recursive map is done on the input array to convert each value
-  in the input array to the expected type, using the typecasting
-  method that would be used for the scalar value.  For example, for
-  model objects, where ids is an integer array column:
-
-   model.set(:ids=>['1', '2']).ids.to_a # => [1, 2]
-
-* The pg_array extension now correctly handles bytea arrays used
-  in bound variables.
-
-* The pg_array extension no longer uses the JSON-based parser for
-  floating point types, since it doesn't handle NaN and Infinity
-  values correctly.
-
-* When typecasting in the pg_array extension, PGArray values are
-  only returned verbatim if they have a matching database type.
-  Otherwise, the underlying array is rewrapped in a new PGArray
-  value with the correct database type.
-
-* H2 clob types are now recognized as strings instead of blobs.
-  Previously the code attempted to do this, but it didn't do so
-  correctly.
-
-* The jdbc/postgres adapter now converts scalar values of
-  the array to the appropriate type.  Previously, if you retrieved
-  a date array, you got back a ruby array of JavaSQL::SQL::Date
-  instances.  Now, you get back a ruby array of ruby Date instances.
-
-* The schema_dumper extension now dumps migrations as change
-  migrations, instead of separate up/down migrations, resulting in
-  simpler code.
-
-* When dumping non-integer foreign keys in the schema dumper, an
-  explicit type is now used.  Previously, the column would have been
-  dumped as an integer column.
-
-* When dumping unsigned integer columns in the schema dumper, add a
-  column > 0 constraint in the dumped migration.
-
-* On Microsoft SQL Server, when updating a dataset with a limit,
-  the limit is now respected.
-
-* When emulating offset using the ROW_NUMBER window function,
-  do not require that the dataset be ordered.  If an order is
-  not provided, default to ordering on all of the columns in
-  the dataset.  If you want to override the default order used
-  in such a case, you need to override the default_offset_order
-  method for the dataset.
-
-* On SQLite, casting to Date/Time/DateTime now calls an SQLite
-  date/datetime function instead of using a cast, as SQLite treats
-  such a cast as a cast to integer.
-
-* When using JRuby 1.6 in ruby 1.9 mode and typecasting a time
-  column, workaround a bug where Time#nsec is 0 even though
-  Time#usec is not.
-
-* The odbc/mssql adapter now correctly handles the case where
-  SCOPE_IDENTITY returns NULL after an insert.
-
-* bin/sequel now accepts multiple -l options for logging to multiple
-  output files.
-
-* In addition to Sequel's rigorous pre-push testing, Sequel now
-  also uses TravisCI for continuous integration testing across
-  a wider range of ruby implementations.
-
-= Backwards Compatibility
-
-* The keys in the :key_hash entry passed to the :eager_loader proc
-  are now method references instead of column references.  For most
-  associations, they are the same thing, but for associations using
-  the :key_column/:primary_key_column/:left_primary_key_column
-  options, the values could be different.  If you were using one
-  of those options and had a custom eager_loader, you should switch
-  from indexing into the :key_hash option to just using the :id_map
-  option.
-
-* The :key_hash entry passed to the :eager_loader proc is now no
-  longer guaranteed to contain key maps for associations other than
-  the one currently being eagerly loaded.  Previously, it contained 
-  key maps for all associations that were being eagerly loaded.  If
-  you have a custom :eager_loader proc that accessed a key map for
-  a separate association that was being loaded concurrently, you'll
-  now have to build the key map manually if it doesn't exist.
-
-* If you previously explicitly specified an :eager_loader_key option
-  when defining an association, you may need to change it so that it
-  is a method reference instead of a column reference, or possibly
-  just omit the option.
-
-* If you have a custom :eager_loader proc for an association where
-  the default :eager_loader_key option references a method that
-  the model does not respond to (or raises an exception), you may
-  need to specify the :eager_loader_key=>nil option.
-
-* In the pg_auto_parameterize extension, String values are no longer
-  automatically casted to text.  This is because the default type of
-  a string literal in PostgreSQL is unknown, not text.  This makes it
-  much less likely to require manual casts, but has the potential to
-  break existing code relying on the automatic cast to text.  As a
-  work around, any query that can no longer be automatically
-  parameterized after this query just needs to add manual casting
-  to text.
-
-* Sequel now raises an exception if you attempt to clone associations
-  with different types, except if one type is one_to_many and the
-  other is one_to_one.  Cloning from other types was usually a bug,
-  and raising an exception early will make it much easier to track
-  such bugs down.
-
-* When running the plugin/extension and PostgreSQL adapter specs,
-  a json library is now required.
-
-* The json/postgres adapter array typecasting internals have been
-  modified, if you were relying on the internals, you may need to
-  update your code.
-
-* The pg_array extension internals changed significantly.  PGArray
-  no longer has any subclasses by default, as parsing is now done
-  in separate objects.  Anyone relying on the pg_array internals
-  will need to update their code.
-
-* The postgres adapter no longer sets up type conversion of int2vector
-  and money types, since in both cases the conversion was incorrect in
-  most cases.  These types will now be returned as strings.  If you are
-  relying on the conversion, you'll need to add your own custom type
-  procs.
-

data/doc/release_notes/3.38.0.txt

@@ -1,234 +0,0 @@
-= New Features
-
-* A pg_row extension has been added that supports PostgreSQL's
-  row-valued/composite types.  You can register support for
-  specific row types:
-
-    DB.register_row_type(:address)
-
-  Then you can create values of that row type:
-
-    ad = DB.row_type(:address, ['555 Foo St.', 'Bar City', '98765'])
-    # or
-    ad = DB.row_type(:address, :street=>'555 Foo St.',
-                          :city=>'Bar City', :zip=>'98765')
-
-  Which you can use in your datasets:
-
-    DB[:people].insert(:name=>'Me', :address=>ad)
-  
-  If you are using the native postgres adapter, when retreiving
-  row type values, they will be returned as instances of the row
-  type, which are hash-like objects:
-
-    ad = DB[:people].get(:address)
-    ad[:street] # => '555 Foo St.'
-    ad[:city]   # => 'Bar City'
-    ad[:zip]    # => '98765'
-
-  If you are also using the pg_array extension, then arrays of
-  composite types are supported automatically.  Composite
-  types can also include arrays of other types as well as other
-  composite types, though recursive composite types are not
-  allowed by PostgreSQL.
-
-  Using arrays and composite types brings one of the benefits
-  of document databases to PostgreSQL, allowing you to store
-  nested structures inside a single row.
-
-* A pg_row_ops extension has been added that adds DSL support
-  for accessing members of row-valued/composite types. You
-  first create a row op:
-
-    r = Sequel.pg_row_op(:row_column)
-
-  Then you can get DSL support for accessing members of that
-  row_column via the #[] method:
-
-    r[:a] # (row_column).a
-
-  This works with composite types containing composite types:
-
-    r[:a][:b] # ((row_column).a).b
-
-  When used in conjunction with the pg_array_ops extension,
-  there is support for composite types that include arrays,
-  as well as arrays of composite types:
-
-    r[1][:a] # (row_column[1]).a
-    r[:a][1] # (row_column).a[1]
-
-  The extension offers additional support for referencing
-  a table's type when it contains a column with the same
-  name, see the RDoc for details.
-
-* A pg_row plugin has been added, that works with the pg_row
-  extension, and allows you to represent row-valued types as
-  Sequel::Model objects (instead of the hash-like objects
-  they use by default).  In your model class, you load the
-  plugin:
-
-    class Address < Sequel::Model(:address)
-      plugin :pg_row
-    end
-
-  Then you can use Address instances in your datasets:
-  
-    ad = Address.new(:street=>'555 Foo St.',
-                     :city=>'Bar City', :zip=>'98765')
-    DB[:people].insert(:name=>'Me', :address=>ad)
-
-  And if you are using the native postgres adapter, the dataset
-  will return the type as a model instance:
-
-    ad = DB[:people].get(:address)
-    ad.street # => '555 Foo St.'
-    ad.city   # => 'Bar City'
-    ad.zip    # => '98765'
- 
-* A pg_typecast_on_load plugin has been added.  This plugin is
-  designed for use with the jdbc/postgres, do/postgres, and
-  swift/postgres adapters, and it is similar to the
-  typecast_on_load plugin.  However, while the typecast_on_load
-  plugin uses setter methods, the pg_typecast_on_load plugin
-  uses the same code that the native postgres adapter uses for
-  typecasting.
-
-* The tinytds adapter now supports a :textsize option to override
-  the default TEXTSIZE setting.  The FreeTDS default is fairly
-  small (~64k), so if you want to use large blob or text columns,
-  you should probably set this to a value larger than the
-  largest text/blob you want to use.
-
-* Sequel.expr when called with a symbol now splits the symbol and
-  returns an Identifier, QualifiedIdentifier, or AliasedExpression, 
-  depending on the content of the symbol.  Previously, it only
-  wrapped the symbol using a Wrapper.
-
-* Identifier#* and QualifiedIdentifier#* when called without any
-  argument now represent a selection of all columns from the
-  represented table:
-
-    Sequel.expr(:table).*          # table.*
-    Sequel.expr(:schema__table).*  # schema.table.*
-
-  This makes it easier to represent the selection of all columns
-  in a table without using the core extensions.
-
-* Model#values now has a Model#to_hash alias.
-
-* SQL::Blob values now have as, cast, and lit methods even if the
-  core extensions are not loaded.
-
-= Other Improvements
-
-* When loading multiple pg_* extensions into a Database instance,
-  the conversion procs are only reset once instead of once per
-  extension.
-
-* All adapters that access PostgreSQL now store type conversion
-  procs, similar to the native postgres adapter.  This has been
-  added to make it easier to write extensions that support
-  advanced PostgreSQL types.
-
-* Database#schema output on PostgreSQL now includes the type oid
-  for each column.
-
-* You can now register custom array types to specific Database
-  instances, using the :type_procs and :typecast_methods_module
-  options, so it is now possible to have custom array types
-  without affecting global state.
-
-* Dropping of columns with defaults now works correctly on
-  Microsoft SQL Server.  Before, it would fail as the related
-  constraint was not dropped first.
-
-* The MySQL type "double(x,y)" is now recognized as a float type.
-
-* The jdbc/jtds and jdbc/derby adapters now handle nil prepared
-  statement values in more cases.
-
-* Blob prepared statement arguments are now handled correctly on
-  jdbc/db2 and jdbc/oracle.
-
-* Sequel now works around a Time#nsec bug in JRuby 1.6 ruby 1.9 mode
-  when using Time values in prepared statements in the jdbc adapter.
-
-* Java::JavaUtil::UUID types are now returned as ruby strings
-  when converting types in the jdbc adapter.
-
-* Real boolean literals are now used on derby 10.7+.  On derby <10.7
-  Sequel still uses (1 = 1) and (1 != 1) for true and false.  This
-  allows you to use boolean columns with a true/false default on
-  derby 10.7+.
-
-* Clobs are now treated as string types instead of blobs on derby,
-  since treating clob as blob doesn't work there.
-
-* The swift adapter now supports an output identifier method.
-
-* The swift adapter now returns blobs as SQL::Blob instances.
-
-* The schema_dumper extension no longer produces code that requires
-  the core extensions.
-
-* All of Sequel's specs now run without the core extensions loaded,
-  ensuring that none of the internals depend on the core extensions.
-  The only exception is the specs for the core extensions themselves.
-
-= Backwards Compatibility
-
-* The pg_* extensions no longer modify core classes if the
-  core_extensions extension is not loaded.  All methods they added now
-  have equivalent methods on the main Sequel module:
-
-    Sequel.pg_array
-    Sequel.pg_array_op
-    Sequel.hstore
-    Sequel.hstore_op
-    Sequel.pg_json
-    Sequel.pg_range
-    Sequel.pg_range_op
-
-* The Sequel::SQL::IdentifierMethods module has been removed.  This
-  module was only included in Symbol if the core_extensions were
-  enabled.  Since it only defined a single method, now the core
-  extensions just define that method directly on Symbol.
-
-* The swift adapter now requires swift-db-{postgres,mysql,sqlite3}
-  gems instead of the swift gem.  swift/postgres requires
-  swift-db-postgres 0.2.0+, swift/sqlite requires swift-db-sqlite
-  0.1.2+, and swift/mysql requires swift-db-mysql.
-
-* Sequel will no longer typecast a string to a PostgreSQL array
-  or hstore column in a model column setter.  This is because the
-  parsers that Sequel uses were designed to support only
-  PostgreSQL's output format.  It's unlikely that a user would
-  provide that format for typecasting, and while there aren't known
-  security issues with the parsers, they were not designed to handle
-  arbtirary user input, so typecasting from string is no longer
-  allowed and will now raise an error.
-
-  The only reason such typecasting was allowed in the first place
-  was to work around issues in the jdbc/postgres, do/postgres, and
-  swift/postgres adapters, using the the typecast_on_load plugin.
-  If you were previously using the typecast_on_load plugin for
-  hstore or array columns, you need to switch to using the new
-  pg_typecast_on_load plugin.
-
-* The private get_conversion_procs method in the postgres adapter
-  no longer accepts an argument.
-
-* The Sequel::Postgres::PGArray::DatabaseMethods singleton
-  define_array_typecast_method method has been removed.  This
-  method was designed for internal use.
-
-* The change to make Sequel.expr split symbols can cause the
-  following type of code to break:
-
-    Sequel.expr(:column___alias).desc
-
-  This is because expr now returns an AliasedExpression, which
-  doesn't support the desc method.  However, as you can't
-  apply an order to an aliased expression, nobody should be
-  relying on this.