Sequel is a lightweight database access toolkit for Ruby.
* Sequel provides thread safety, connection pooling and a concise DSL
for constructing database queries and table schemas.
* Sequel also includes a lightweight but comprehensive ORM layer for
mapping records to Ruby objects and handling associated records.
* Sequel makes it easy to deal with multiple records without having
to break your teeth on SQL.
* Sequel currently has adapters for ADO, DB2, DBI, Informix, JDBC,
MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3.
Sequel 2.1.0 has been released and should be available on the gem
mirrors. 2.1.0 has the following exciting new features:
Model Improvements
···
------------------
* one_to_many/many_to_many associations now support a :limit option,
adding a limit/offset to the records returned. This was possible
before using a block, so it is just added for convenience.
* Associations now support a :read_only option, which doesn't create
methods that modify the database.
* Associations now support a :graph_select option, which allows
specifying the columns of associated models to include when using
eager_graph.
* one_to_many associations now have a :one_to_one option. When used
it creates a getter and setter method similar to many_to_one. This
fills the same role as ActiveRecord's has_one, but it is
implemented as a couple of convenience methods over one_to_many, so
it still requires that you specify the association name as a
plural.
* Model datasets now have to_hash augmented so that it can be called
without any arguments, in which case it yields an identity map (a
hash with keys being primary key values and values being model
instances).
* The Model.set_sti_key method was added, for easily setting up
single table inheritance. It should be called only in the parent
class.
* Calls to def_dataset_method with a block are now cached and
reapplied to the new dataset if set_dataset is called afterward,
or in a subclass.
* All validation methods can now be made conditional via an :if
option, which takes either a symbol (which specifies an instance
method) or a proc (which is instance_evaled).
* Model#set and Model#update have been added back, they are now
aliases of #set_with_params and #update_with_params.
* Models now have set_only/set_except/update_only/update_except
instance methods that take a hash (like you would provide to
set or update) and additional arguments specifying which columns
to allow or disallow.
* Models now have a set_allowed_columns and set_restricted_columns
methods, which operate similarly to ActiveRecord's attr_accessible
and attr_protected. It is recommend that you use the set_only or
update_only instead of these methods, though. You can ignore the
allowed or restricted columns by using #set_all or #update_all.
* The primary key column(s) is restricted by default. To allow it to
be set via new/set/update, use:
Sequel::Model.unrestrict_primary_key # Global
Artist.unrestrict_primary_key # Per Class
* It is now easy to override the one_to_many/many_to_many association
methods that modify the database (add_/remove_/remove_all_), as
they have been broken into two methods, one that handles the
caching features and a private one (prepended with an _) that
handles the database changes (and which you can easily override
without worrying about the caching).
Table Joining
-------------
Dataset#join_table got a nice overhaul. You can now use any join
type your database allows:
DB[:artist].join_table(:natural, :albums)
DB[:numbers].join_table(:cross, :numbers)
You can now specify the conditions as
* String: "a.b = c.d" # ON a.b = c.d
* Expression :x < :y # ON x < y
* Array of Symbols: [:x, :y, :z] # USING (x, y, z)
* nil # no conditions, used for NATURAL or CROSS joins
Dataset#join_table also takes a block that yields three arguments:
* join_table_alias - The alias/name of the table currently being
joined
* last_join_table_alias - The alias name of the last table joined
(if there was one) or the first FROM table (if not).
* joins - An array of JoinClause objects for all previous joins in
the query.
Using the block you can specify conditions for complex joins without
needing to know in advance what table aliases will be used.
Expanded SQL Syntax Support
---------------------------
SQL Case statements are now supported directly using hashes or
arrays:
{:x > 1 => 1}.case(0)
# CASE WHEN x > 1 THEN 1 ELSE 0 END
[[{:x=>1}, 0], [:x < 1, 1], [:x > 1, 2]].case(-1)
# CASE WHEN x = 1 THEN 0 WHEN x < 1 THEN 1 WHEN x > 1 THEN 2
ELSE -1 END
You should use an array instead of a hash for multiple conditions
unless all conditions are orthogonal.
The SQL extract function has special syntax:
EXTRACT(day FROM date)
This syntax is now supported via the following ruby code:
:date.extract(:day)
Other Notable Changes
---------------------
* The sequel command line tool can now run migrations. The -m
option specifies the directory holding the migration files,
and the -M options specifies the version to which to migrate.
* The PostgreSQL adapter supports nested transactions/savepoints.
* The schema parser now understands decimal fields, and will
typecast to BigDecimal.
* PostgreSQL's numeric type is now recognized and returned as
BigDecimal.
* HAVING now comes before ORDER BY, which most databases seem to
prefer. If your database wants HAVING after ORDER BY, please
let us know.
* Symbol#qualify now exists, to specify the table name for a given
symbol, similar to the use of #as to specify an alias. This is
mainly helpful in conjuction with the #join_table block, as that
provides the table aliases to use to qualify the columns inside
the block.
* BitwiseMethods (&, |, ^, ~, <<, >>) have been added to the
NumericExpression class, so you can do the following:
(x + 1) ^ 10 # SQL: (x + 1) ^ 10
~(x + 1) # SQL: ~(x + 1)
Usually, &, |, and ~ operate in a logical manner, but for
NumericExpressions, they take on their usual bitwise meaning,
since logical operations only make sense for booleans.
* #cast_numeric and #cast_string exist for Symbols, Strings, and
other Sequel Expressions, which return the results casted and
wrapped in either NumericExpression or StringExpression, so you
can use the BitwiseMethods (&, |, ^, ~, <<, >>) or
StringConcatenationMethods (+) directly.
# Dataset#to_hash can take only one argument, in which case it uses
that argument to specify the key, and uses the entire hash for the
value.
# Dataset#graph can now take an array of columns to select from the
joined table via the :select option.
# Dataset#filter and similar methods now combine the block and
regular argument conditions if both are given, instead of ignoring
the regular argument conditions.
# Dataset#filter(false) can now be used to make sure that no records
are returned. Dataset#filter(true) also works, but it's a no-op.
Before, these raised errors.
# Dataset#count does a subquery for a dataset using DISTINCT, since
the otherwise it would yield a count for the query without
DISTINCT.
ParseTree Support Officially Deprecated
---------------------------------------
The support for ParseTree-based block filters has officially been
deprecated and will be removed in Sequel 2.2. To use the
expression filters (which don't require ParseTree) inside blocks,
use:
SEQUEL_NO_PARSE_TREE = true
require 'sequel'
# OR
require 'sequel'
Sequel.use_parse_tree = false
This is the default if ParseTree cannot be loaded. If ParseTree
can be loaded, it remains the default, in order not to immediately
break existing code.
With this set, you can use the expression filters inside of blocks:
dataset.filter{((:x + 1) & 10 < :y) & :z}
That doesn't gain you all that much, but there are some methods
that feed block arguments into filter, such as the following:
dataset.first(5){((:x + 1) & 10 < :y) & :z}
Which will get you the first 5 records matching the condition.
Backwards Incompatible Changes
------------------------------
* To change the datetime classe used from Time to DateTime, you
now use:
Sequel.datetime_class = DateTime # instead of Sequel.time_class
* Models now raise errors if you try to access a missing or
restricted method via new/set/update, instead of just silently
skipping that parameter. To get the old behavior:
Sequel::Model.strict_param_setting = false
* The association_dataset method now takes into account the :eager
option and the block argument, where it didn't before. It also
takes into account the new :limit option.
* Association methods now raise errors in most cases if the model
doesn't have a valid primary key.
* Dataset#join_table used to allow a symbol as a conditions argument
as a shortcut for a hash:
DB[:artist].join(:albums, :artist_id)
# ON albums.artist_id = artists.id
With the changes to #join_table, this no longer works. It would
now be interpreted as a boolean column:
DB[:artist].join(:albums, :artist_id)
# ON artists.id
Use the following slightly longer version for the old behavior:
DB[:artist].join(:albums, :artist_id=>:id)
# ON albums.artist_id = artists.id
* MySQL users need to be careful when upgrading, the following code
will once again cause an error:
DB[:artists].each{|artist| DB[:albums].each{|album| ...}}
To fix it, change the code to:
DB[:artists].all{|artist| DB[:albums].each{|album| ...}}
The issue is the MySQL adapter doesn't release the database
connection while running each, and the second call to each gets the
same database connection (while the other query is still running),
because it is in the same thread. Using #all for the outside query
ensures that the database connection is released before the block is
called.
The reason for this change was that the workaround provided for
MySQL could potentially cause issues with transactions for all
adapters.
* String#asc and String#desc are no longer defined, as ordering on a
plain string column should be a no-op. They are still defined
on LiteralStrings.
* You can no longer abuse the SQL::Function syntax to use a table
alias with specified columns (e.g. :table[:col1, :col2, :col3])
or to cast to types (e.g. :x.cast_as(:varchar[20])). Use a
LiteralString in both cases.
If you have any questions, please post on the Google Group.
Thanks,
Jeremy
* {Source code}[http://github.com/jeremyevans/sequel]
* {Bug tracking}[http://code.google.com/p/ruby-sequel/issues/list]
* {Google group}[http://groups.google.com/group/sequel-talk]
* {RDoc}[http://sequel.rubyforge.org]
--
Posted via http://www.ruby-forum.com/.