ANN: Sequel 2.12.0 Released


Jeremy Evans

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 supports advanced database features such as prepared
statements, bound variables, stored procedures, master/slave
configurations, and database sharding.
* Sequel makes it easy to deal with multiple records without having
to break your teeth on SQL.
* Sequel currently has adapters for ADO, DataObjects, DB2, DBI,
Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL
and SQLite3.

Sequel 2.12.0 has been released and should be available on the gem
mirrors. The 2.12.0 release adds numerous improvements:


Sequel 2.12 is really just a stepping stone to Sequel 3.0, which will
be released next month. All major changes currently planned for 3.0
have been made in 2.12, but 2.12 contains many features that have
been deprecated and will be removed or moved into extensions or
plugins in 3.0.

Deprecation Logging

If you use a deprecated method or feature, Sequel will by default
print a deprecation message and 10 lines of backtrace to standard
error to easily allow you to figure out which code needs to be
updated. You can change where the deprecation messages go and how
many lines of backtrace are given using the following:

# Log deprecation information to a file
Sequel::Deprecation.output ='deprecated.txt', 'wb')

# Use 5 lines of backtrace when logging deprecation messages
Sequel::Deprecation.backtraces = 5

# Use all backtrace lines when logging deprecation messages
Sequel::Deprecation.backtraces = true

# Don't include backtraces in the deprecation logging
Sequel.Deprecation.backtraces = false

# Turn off all deprecation logging
Sequel::Deprecation.output = nil

Deprecated Features Moving to Extensions

* Migrations are being moved into sequel/extensions/migration. There
isn't any reason that they should be loaded in normal use since
they are used so rarely. The sequel command line tool uses this
extension to run the migrations.

* Adding the blank? method to all objects has been moved into

* Dataset#print and Sequel::prettyTable have been moved into

* Dataset#query and related methods have been moved into

* Dataset#paginate and related methods have been moved into

* String inflection methods (e.g. "people".singularize) have been
moved into sequel/extensions/inflector.

* String date/time conversion methods (e.g. '2000-01-01'.to_date)
have been moved into sequel/extensions/string_date_time.

Deprecated Model Features Moving to Plugins

* Model validation class methods have been moved to a plugin. Sequel
users are encouraged to write their own validate instance method
instead. A new validation_helpers plugin has been added to make
this easier, it's explained in the New Features section. If you
want to continue using the validation class methods:

Sequel::Model.plugin :validation_class_methods

* Model hook class methods have been moved to a plugin. Sequel users
are encouraged to write their own hook instance methods, and call
super to get hooks specified in superclasses or plugins. If you
want to continue using the hook class methods:

Sequel::Model.plugin :hook_class_methods

* Model schema methods (e.g. Model.set_schema, Model.create_table,
Model.drop_table) have been moved to a plugin. The use of these
methods has been discouraged for a long time. If you want to use

Sequel::Model.plugin :schema

* Model.set_sti_key has been moved to a plugin. So you should

MyModel.set_sti_key :key_column


MyModel.plugin :single_table_inheritance, :key_column

* Model.set_cache has been moved to a plugin. So you should change:

MyModel.set_cache cache_store, opts


MyModel.plugin :caching, cache_store, opts

* Model.serialize has been moved to a plugin. So you should change:

MyModel.serialize :column, :format=>:yaml


MyModel.plugin :serialization, :yaml, :column

Because the previous serialization support depended on dataset
transforms, the new serialization support is implemented
differently, and behavior may not be identical in all cases.
However, this should be a drop in replacement for most users.

Deprecated Features To Be Removed in Sequel 3.0

* Dataset#transform is deprecated without any replacement planned.
It was announced on the Sequel mailing list that transforms would
be removed unless someone said they needed them, and nobody said
that they did.

* Dataset#multi_insert and Dataset#import are no longer aliases
of each other. Dataset#multi_insert now takes an array of hashes,
and Dataset#import now takes an array of columns and an array
of arrays of values. Using multi_insert with import's API or
vice-versa is deprecated.

* Calling Dataset#[] with no arguments or an integer argument is

* Calling Dataset#map with both an argument and a block is

* Database#multi_threaded? and Database#logger are both deprecated.

* Calling Database#transaction with a symbol to specify which server
to use is deprecated. You should now call it with an option hash
with a :server key.

* Array#extract_options! and Object#is_one_of? are both deprecated.

* The metaprogramming methods taken from metaid are deprecated and
have been moved into Sequel::Metaprogramming. If you want them
available to specific objects/classes, just include or extend with
Sequel::Metaprogramming. If you want all objects to have access to
the metaprogramming methods, install metaid. Note that the
class_def method from metaid doesn't exist in
Sequel::Metaprogramming, since it really isn't different from
define_method (except it is public instead of private).

* Module#class_attr_overridable, #class_attr_reader, and
#metaalias are deprecated.

* Using Model#set or #update when the columns for the model are not
set and you provide a hash with symbol keys is deprecated.
Basically, you must have setter methods now for any columns used in
#set or #update.

* Model#set_with_params and #update_with_params are deprecated, use
#set and #update instead.

* Model#save! is deprecated, use #save:)validate=>false).

* and Model.is_a are deprecated, use Model.plugin.

* Model.str_columns, Model#str_columns, #set_values, and
#update_values are deprecated. You should use #set and
#update instead of #set_values and #update_values, though they
operate differently.

* Model.delete_all, Model.destroy_all, Model.size, and Model.uniq
are deprecated, use .delete, .destroy, .count, and .distinct.

* Model.belongs_to, Model.has_many, and Model.has_and_belongs_to_many
are deprecated, use .many_to_one, .one_to_many, and .many_to_many.

* Model#dataset is deprecated, use Model.dataset.

* SQL::CastMethods#cast_as is deprecated, use #cast.

* Calling Database#schema without a table argument is deprecated.

* Dataset#uniq is deprecated, use Dataset#distinct.

* Dataset#symbol_to_column_ref is deprecated, use #literal.

* Dataset#quote_column_ref is deprecated, use #quote_identifier.

* Dataset#size is deprecated, use #count.

* Passing options to Dataset#each, #all, #single_record,
#single_value, #sql, #select_sql, #update, #update_sql, #delete,
#delete_sql, and #exists is deprecated. Modify the options first
using clone or a related method, then call one of the above

* Dataset#create_view and #create_or_replace_view are deprecated,
use the database methods instead.

* Dataset.dataset_classes, #model_classes, #polymorphic_key, and
#set_model are deprecated.

* Database#>> is deprecated.

* String#to_blob and SQL::Blob#to_blob are deprecated, use

* The use of Symbol#| to create array subscripts is deprecated,
use Symbol#sql_subscript.

* Symbol#to_column_ref is deprecated, use Dataset#literal.

* String#expr is deprecated, use String#lit.

* Array#to_sql, String#to_sql, and String#split_sql are deprecated.

* Passing an array to Database#<< is deprecated.

* Range#interval is deprecated.

* Enumerable#send_each is deprecated.

* When using ruby 1.8, Hash#key is deprecated.

* is deprecated, use Sequel.connect.

* Sequel.use_parse_tree and Sequel.use_parse_tree= are deprecated.

* All upcase_identifier methods and the :upcase_identifiers database
option are deprecated, use identifier_input_method = :upcase

* Using a virtual row block without an argument is deprecated, see
Sequel.virtual_row_instance_eval= under New Features.

* When using the JDBC adapter, Java::JavaSQL::Timestamp#usec is
deprecated. Sequel has returned Java::JavaSQL::Timestamp as
DateTime or Time for a few versions, so this shouldn't affect most

* Sequel will no longer require bigdecimal/util, enumerator, or yaml
in 3.0. If you need them in your code, make sure you require
them yourself. Using features added by requiring these standard
libaries will not bring up a deprecation warning, for obvious

* Sequel::Error::InvalidTransform, Sequel::Error::NoExistingFilter,
and Sequel::Error::InvalidStatement exceptions will be removed in
Sequel 3.0. You will not get a deprecation message if you reference
them in 2.12.

* Sequel::Model::Validation::Errors is deprecated, use
Sequel::Model::Errors instead. Referencing the old name will not
bring up a deprecation message.

New Features

* Sequel.virtual_row_instance_eval= was added, which lets you give
Sequel 2.12 the behavior that will be the standard in 3.0.
It changes blocks passed to Dataset#filter, #select, or #order that
don't accept arguments (or accept any number of arguments) to
instance eval the block in the context of a new VirtualRow
instance instead of passing a new VirtualRow instance to the block.
It allows you to change code that looks like this:

dataset.filter{|o| (o.number > 10) & ( > 'M')}


dataset.filter{(number > 10) & (name > 'M')}

When instance_eval is used, only local variables are available
to the block. Any calls to instance methods will be interpreted
as calling VirtualRow#method_missing, which generates identifiers
or functions. When virtual_row_instance_eval is enabled, the
following type of code will break:

# amount is a instance method
dataset.filter{:number + amount > 0}

Just like this example, the only type of code that should break is
when a virtual row block was used when it wasn't necessary (since
it doesn't use the VirtualRow argument).

When Sequel.virtual_row_instance_eval = false, using a virtual row
block that doesn't accept an argument will cause a deprecation

Here's a regular expression that should catch most places where you
are using a virtual row block without an argument.

egrep -nr
*(\([^)]*\) *)?){*[^|]' *

An RDoc page explaining virtual row blocks was added as well.

* A validation_helpers model plugin was added that allows you to do
validations similar to the old class level validations inside
the Model#validate instance method. The API has changed, but it's
capable of most of the same validations. It doesn't handle
acceptance_of or confirmation_of validations, as those shouldn't be
handled in the model.

# Old class level validations
validates_format_of :col, :with=>/.../
validates_length_of :col, :maximum=>5
validates_length_of :col, :minimum=>3
validates_length_of :col, :is=>4
validates_length_of :col, :within=>3..5
validates_not_string :col
validates_numericality_of :col
validates_numericality_of :col, :eek:nly_integer=>true
validates_presence_of :col
validates_inclusion_of :col, :in=>[3, 4, 5]
validates_uniqueness_of :col, :col2
validates_uniqueness_of([:col, :col2])

# New instance level validations
def validate
validates_format /.../, :col
validates_max_length 5, :col
validates_min_length 3, :col
validates_exact_length 4, :col
validates_length_range 3..5, :col
validates_not_string :col
validates_numeric :col
validates_integer :col
validates_presence :col
validates_includes([3,4,5], :col)
validates_unique :col, :col2
validates_unique([:col, :col2])

Another change made is to specify the same type of validation on
multiple attributes, you must use an array:

# Old
validates_length_of :name, :password, :within=>3..5

# New
def validate
validates_length_range 3..5, [:name, :password]

The :message, :allow_blank, :allow_missing, and :allow_nil options
are still respected. The :tag option is not needed as instance level
validations work with code reloading without workarounds. The :if
option is also not needed for instance level validations:

# Old
validates_presence_of :name, :if=>:new?
validates_presence_of :pass, :if=>{flag > 3}

# New
def validate
validates_presence:)name) if new?
validates_presence:)pass) if flag > 3

The validates_each also doesn't have an equivalent instance method,
since it is much easier to just write your own validation:

# Old
validates_each:)date) do |o,a,v|
o.errors.add(a, '...') unless v >

# New
def validate
errors.add:)date, '...') unless date >

* MySQL adapter datasets now have on_duplicate_key_update and
insert_ignore methods which modify the SQL used to support
ON DUPLICATE KEY UPDATE and INSERT INGORE syntax in multi_insert
and import.

* If you use the MySQL native adapter, you can set:

Sequel::MySQL.convert_invalid_date_time = nil

to return dates like "0000-00-00" and times like "25:00:00" as
nil values instead of raising an error. You can also set it
to :string to return the values as strings.

* You can now use Sequel without modifying any core classes, by
defining a SEQUEL_NO_CORE_EXTENSIONS constant or environment
variable. In 2.12, this may still add some deprecated methods to
the core classes, but in 3.0 no methods will be added to the core
classes if you use this.

* You can now use Sequel::Model without the associations
implementation by defining a SEQUEL_NO_ASSOCIATIONS constant or
environment variable.

Other Improvements

* Model column accessors have been made faster and the overhead of
creating them has been reduced significantly.

* ~{:bool_col=>true} now generates an bool_col IS NOT TRUE filter
instead of bool_col != TRUE. This makes it return records with
NULL values. If you only want to have false records, you should
use {:bool_col=>false}. This works better with SQL's 3 valued
boolean logic.

It is slightly inconsistent with ~{:col=>1}, since that won't
return values where col is NULL, but it gives the user the ability
to create an IS [NOT] (TRUE|FALSE) filter, which Sequel previously
did not support.

If you really want the old behavior, you can change it to

* Model.use_transactions was added for setting whether model objects
should use transactions when destroying or saving records. Like
most Sequel options, it's settable on a global, per model, and
per object basis:

Sequel::Model.use_transactions = false
MyModel.use_transactions = true
my_model.use_transactions = false

You can also turn it on or off for specific save calls:>true)

* The Oracle adapter now supports schema parsing.

* When using Model.db=, all current dataset options are copied to
a new dataset created with the new db.

* Model::Errors#count was refactored to improve performance.

* Most exception classes that were located under Sequel::Error are
now located directly under Sequel. The old names are not
deprecated (unless mentioned above), but their use is now
discouraged. The exceptions have the same name except that
Sequel::Error::poolTimeoutError changed to Sequel::poolTimeout.

* Dataset#where now always affects the WHERE clause. Before, it
was just an alias of filter, so it modified the HAVING clause
if the dataset already had a HAVING clause.

* The optimization of Model.[] introduced in 2.11.0 broke on
databases that didn't support LIMIT. The optimization now works
on those databases.

* All of the the RDoc documentation was reviewed and many updates
were made, resulting in significantly improved documentation

* Model.def_dataset_method now works when the model doesn't have an
associated dataset, as it will add the method to a dataset
given to set_dataset in the future.

* Database#get and #select now take a block that is passed to
the dataset they create.

* You can disable the use of INSERT RETURNING in the shared
PostgreSQL adapter using disable_insert_returning. This is mostly
useful if you are inserting a large number of records.

* A bug relating to aliasing columns in the JDBC adapter has been

* Sequel can now create and drop schema-qualified views.

* Performance of Dataset#destroy for model datasets was improved.

* The specs now run on Rspec 1.2.

* Internal dependence on the methods that Sequel adds to core
classes has been eliminated, any internal use of methods that
Sequel adds to the core classes is now considered a bug.

* A possible bug where Database#rename_table would not remove a
cached schema entry has been fixed.

* The Oracle and MySQL adapters now raise an error as soon as you
call distinct on a dataset, instead of waiting until the SQL is

Backwards Compatibilty

* Saving a newly inserted record in an after_create or after_save
hook is no longer broken. It broke in 2.10 as a side effect of
allowing the hook to check whether or not the record was a new
record. The code has been changed so that a @was_new instance
variable will be defined to true if the record was just created.

Similarly, instead of not modifying changed_columns until after
the after hooks run, a @columns_updated instance variable will
be available in the after hooks that is a hash of exactly what
attribute keys and values were used in the update.

These changes break compatibility with 2.11.0 and 2.10.0, but
restore compatibility with 2.9.0 and previous versions.

* PostgreSQL no longer uses savepoints for nested transactions by
default. If you want to use a savepoint, you have to pass the
:savepoint option to the transaction method. Using savepoints
by default broke expectations when a method raised Rollback to
rollback the transaction, and it only rolled back to the last

* The anonymous model classes created by Sequel::Model() are now
stored in Model::ANONYMOUS_MODEL_CLASSES instead of the @models
class instance variable of the main module.

* The mappings of adapter schemes to classes are now stored in
Sequel::ADAPTER_MAP instead of the Database @@adapters class

* Model instances no longer contain a reference to their class's

* Database schema sql methods (e.g. alter_table_sql) are now private.

* Database#[] no longer accepts a block. It's not possible to call
it with a block in general usage, anyway.

* The Sequel::Schema::SQL module no longer exists, the methods it
included were placed directly in the Sequel::Database class.

* The Sequel::SQL::SpecificExpression class has been removed,
subclasses now inherit from Sequel::SQL::Expression.

* Sequel now requires its own files with an absolute path.

* The file hierarchy of the sequel library changed significantly.


* {Website}[]
* {Source code}[]
* {Bug tracking}[]
* {Google group}[]
* {RDoc}[]

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Latest member

Latest Threads