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, CUBRID,
DataObjects, DB2, DBI, Firebird, IBM_DB, Informix, JDBC, MySQL,
Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, Swift, and
TinyTDS.
Sequel 3.41.0 has been released and should be available on the gem
mirrors.
= New Features
* A connection_validator extension has been added, which
automatically determines if connections checked out from the pool
are still valid. If they are not valid, the connection is
disconnected and another connection is used automatically,
transparent to user code.
Checking if connections are valid requires a query, so this
extension causes a performance hit. For that reason, connections
are only checked by default if they have been inactive for more than
a configured amount of time (1 hour by default). You can choose to
validate connections on every checkout via:
DB.pool.connection_validation_timeout = -1
However, this can cause a substantial performance hit unless you are
purposely using coarse connection checkouts via manual calls to
Database#synchronize (for example, in a Rack middleware). Using
coarse checkouts can greatly reduce the amount of concurrency that
Sequel supports (for example, limiting the number of concurrent
requests to the number of database connections), so this method is
not without its tradeoffs.
* Sequel.delay has been added for a generic form of delayed
evaluation. This method takes a block and delays evaluating it
until query literalization. By default, Sequel evaluates most
arguments immediately:
foo = 1
ds = DB[:bar].where(:baz=>foo)
# SELECT * FROM bar WHERE (baz = 1)
foo = 2
ds
# SELECT * FROM bar WHERE (baz = 1)
Using Sequel.delay, you can delay the evaluation:
foo = 1
ds = DB[:bar].where(:baz=>Sequel.delay{foo})
# SELECT * FROM bar WHERE (baz = 1)
foo = 2
ds
# SELECT * FROM bar WHERE (baz = 2)
* Sequel now supports the :unlogged option when creating tables on
PostgreSQL, to create an UNLOGGED table.
* On SQLite, Database#transaction now supports a :mode option for
setting up IMMEDIATE/EXCLUSIVE SQLite transactions. Sequel also
supports a Database#transaction_mode accessor for setting the
default transaction mode on SQLite.
* Most pg_* extension objects (e.g. PGArray) now support the #as
method for creating an SQL::AliasedExpression object.
* The single_table_inheritance plugin now supports non-bijective
mappings. In lay terms, this means that a one-to-one mapping
of column values to classes is no longer required. You can now
have multiple column values that map to a single class in the
:model_map option, and specify a :key_chooser option to choose
which column value to use for the given model class.
* The touch plugin now handles the touching of many_to_many
associations, and other associations that use joined datasets.
* ConnectionPool#pool_type has been added. It returns a symbol
representing the type of connection pool in use (similar to
Database#database_type).
* Database#valid_connection? has been added for checking if a given
connection is still valid.
* Database#disconnect_connection is now part of the public API, and
can be used to disconnect a given connection.
= Other Improvements
* Uniqueness validation now correctly handles nil values.
Previously, it checked the underlying table for other rows where
the column IS NULL, but that is incorrect behavior. Sequel's new
(correct) behavior is to skip the uniqueness check if the column
is nil.
* Foreign key parsing is now supported on Microsoft SQL Server.
* Dataset#reverse and #reverse_order now accept virtual row blocks.
* Changing the name of the primary key column, and possibly other
schema changes on the primary key column, are now supported on
MySQL.
* Primary key columns are now specifically marked as NOT NULL on
SQLite, as non-integer primary keys on SQLite are not considered
NOT NULL by default.
* Failure to create a native prepared statement is now handled
better in the postgres, mysql, and mysql2 adapters.
* Firebird now emulates selecting data without an underlying table
(e.g. DB.get(1)).
* Finding the name of the constraint that sets column defaults on
Microsoft SQL Server now works correctly on JRuby 1.7.
* An additional type of disconnect error is now recognized in the
jdbc/sqlserver adapter.
* Many adapters have been fixed so that they don't raise an exception
if trying to disconnect an already disconnected connection.
* Many adapters have been fixed so that
Database#log_connection_execute logs and executes the given SQL
on the connection.
* Many adapters have been fixed so that
Database#database_error_classes returns an array of database
exception classes for that adapter.
* Database#log_exception now handles a nil exception message.
* Dataset#limit(nil, nil) now resets offset in addition to limit, but
you should still use Dataset#unlimited instead.
* A bin/sequel usage quide has been added to the documentation.
= Backwards Compatibility
* Sequel now treats clob columns as strings instead of blobs
(except on DB2 when use_clob_as_blob = true). This can make it
so the values are returned as strings instead of SQL::Blob values.
Since SQL::Blob is a String subclass, this generally will
not affect user code unless you are passing the values as input
to a separate blob column.
* The Database <-> ConnectionPool interface was completely changed.
Sequel no longer supports custom connection procs or disconnection
procs in the connection pools. The :disconnection_proc Database
option is no longer respected, and blocks passed to Database.new
are now ignored.
This change should not be user-visible, but if you had any code
that was monkeying with the connection pool internals, you may
need to modify it.
* Code that was using the uniqueness check to also check for presence
should add a separate check for presence. Such code was broken,
as it only worked if there was already a NULL column value in the
table. If you were relying on this broken behavior, you should
clean up the NULL data in the column and then mark the database
column as NOT NULL.
* If you have code that specifically abuses the fact that non-integer
primary keys on SQLite allow NULL values by default, it will no
longer work.
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/.