Sequel is a lightweight database access toolkit for Ruby.
* Sequel provides thread safety, connection pooling and a concise
DSL for constructing SQL queries and table schemas.
* Sequel includes a comprehensive ORM layer for mapping records to
Ruby objects and handling associated records.
* Sequel supports advanced database features such as prepared
statements, bound variables, stored procedures, savepoints,
two-phase commit, transaction isolation, master/slave
configurations, and database sharding.
* Sequel currently has adapters for ADO, Amalgalite, DataObjects,
DB2, DBI, Firebird, IBM_DB, Informix, JDBC, MySQL, Mysql2, ODBC,
OpenBase, Oracle, PostgreSQL, SQLite3, Swift, and TinyTDS.
Sequel 3.37.0 has been released and should be available on the gem
mirrors.
= 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
...
exclusion_constraint([[: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.
Thanks,
Jeremy
* {Website}[http://sequel.rubyforge.org]
* {Source code}[http://github.com/jeremyevans/sequel]
* {Blog}[http://sequel.heroku.com]
* {Bug tracking}[http://github.com/jeremyevans/sequel/issues]
* {Google group}[http://groups.google.com/group/sequel-talk]
* {RDoc}[http://sequel.rubyforge.org/rdoc]
···
--
Posted via http://www.ruby-forum.com/.