# ANN: Sequel 3.37.0 Released **URL:** \ **Category:** ruby-talk\ **Created:** [2 July 2012 20:27 UTC](https://rubytalk.org/t/ann-sequel-3-37-0-released/65805 "2012-07-02T20:27:11Z")\ **Posts on this page:** 1\ **Page:** 1
**Author:** ![7stud2](https://avatars.discourse-cdn.com/v4/letter/7/9de053/32.png) [@7stud2](https://rubytalk.org/u/7stud2)\ **Post date:** [2 July 2012 20:27 UTC](https://rubytalk.org/t/ann-sequel-3-37-0-released/65805/1 "2012-07-02T20:27:11Z")
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](http://sequel.rubyforge.org)] \* {Source code}[[http://github.com/jeremyevans/sequel](http://github.com/jeremyevans/sequel)] \* {Blog}[[http://sequel.heroku.com](http://sequel.heroku.com)] \* {Bug tracking}[[http://github.com/jeremyevans/sequel/issues](http://github.com/jeremyevans/sequel/issues)] \* {Google group}[[http://groups.google.com/group/sequel-talk](http://groups.google.com/group/sequel-talk)] \* {RDoc}[[http://sequel.rubyforge.org/rdoc](http://sequel.rubyforge.org/rdoc)] > **ยทยทยท** > > -- > Posted via [http://www.ruby-forum.com/](http://www.ruby-forum.com/).