Last Update: 2011-07-16 11:31:03 -0700

New Plugins

  • A json_serializer plugin was added that allows you to serialize model instances or datasets to JSON using to_json. It requires the json library. The API was modeled on ActiveRecord’s JSON serialization support. You can use :only and :except options to specify the columns included, :include to specify associations to include, as well pass options to nested associations using a hash. In addition to serializing to JSON, it also adds support for parsing JSON to model objects via JSON.parse or from_json.

  • An xml_serializer plugin was added that allows you to serialize model instances or datasets to XML. It requries the nokogiri library. It has a similar API to the json_serializer plugin, using to_xml instead of to_json, and the from_xml class method instead of JSON.parse.

  • A tree plugin was added that allows you to treat Sequel::Model objects as being part of a tree. It provides similar features to rcte_tree, but works on databases that don’t support recursive common table expressions. In addition to the standard parent and children associations, it provides instance methods to get the ancestors, descendants, and siblings of the given tree node, and class methods to get the roots of the tree.

  • A list plugin was added that allows you to treat Sequel::Model objects as being part of a list. This adds instance methods to get the next and prev items in the list, or to move the item to a specific place in the list. You can specify that all rows in the table belong to the same list, or specify arbitrary scopes so that the same table can contain many separate lists.

Other New Features

  • Sequel is now compatible with Ruby 1.9.2pre3.

  • Sequel now supports prepared transactions/two-phase commit on PostgreSQL, MySQL, and H2. You can specify that you want to use prepared transactions using the :prepare option which should be some transaction id string:

    DB.transaction(:prepare=>'some string') do ... end

    Assuming that no exceptions are raised in the transaction block, Sequel will prepare the transaction. You can then commit the transaction later:

    DB.commit_prepared_transaction('some string')

    If you need to rollback the prepared transaction, you can do so as well:

    DB.rollback_prepared_transaction('some string')
  • Sequel now supports customizable transaction isolation levels on PostgreSQL, MySQL, and Microsoft SQL Server. You can specify the transaction isolation level to use for any transaction using the :isolation option with an :uncommitted, :committed, :repeatable, or :serializable value:

    DB.transaction(:isolation=>:serializable) do ... end

    You can also set the default isolation level for transactions via the transaction_isolation_level Database attribute:

    DB.transaction_isolation_level = :committed

    If you are connecting to Microsoft SQL Server, it is recommended that you set a default transaction isolation level if you plan on using this feature.

  • You can specify a NULLS FIRST/LAST ordering by using the :nulls=>:first/:last option to asc and desc:

    # ORDER BY release_date DESC NULLS FIRST,
    #          name ASC NULLS LAST

    This syntax is supported by PostgreSQL 8.3+, Firebird 1.5+, Oracle, and probably some other databases as well, and makes it possible for the user to specify whether NULL values should sort before or after other values.

  • Sequel::Model.find_or_create now accepts a block that is a yielded a new model object to be created if an existing model object is not found.

    Node.find_or_create(:name=>'A'){|i| i.parent_id = 4}
  • The :frame option for windows and window functions can now be a string that is used literally in the SQL. This is necessary if you want to specify a custom frame, such as one that uses a specific number of rows preceding or following.

  • Savepoints are now supported on H2.

  • A :methods_module association option was added, allowing you to specify the module into which association instance methods are placed. By default, it uses the module containing the column accessor methods.

Other Improvements

  • The :encoding option for the native MySQL adapter should now work correctly in all cases. This fix was included in 3.12.1.

  • Sequel now handles arrays of two element arrays automatically when using them as the value of a filter hash:

    DB[a].filter([:a, :b]=>[[1, 2], [3, 4]])

    Previously, you had to call .sql_array on the array in order to tell Sequel that it was a value list and not a conditions specifier.

  • Sequel no longer attempts to use class polymorphism in the class_table_inheritance plugin if you don’t specify a cti_key.

  • When using the native SQLite adapter, prepared statements are now cached per connection for increased performance. Previously, Sequel prepared a new statement for every query.

  • tinyint(1) columns are now handled as booleans when connecting to MySQL via JDBC.

  • On PostgreSQL, if no :schema option is provided for Database#tables, table_exists?, or schema, and no default_schema is used, assume all schemas except the default non-public ones. Previously, it assumed the public schema for tables and table_exists?, but did not assume any schema for schema.

    This fixes issues if you use table names that overlap with table names in the information_schema, such as domains. It’s still recommended that you specify a default_schema if you are using a schema other than public.

  • Unsigned integers are now handled correctly in the schema dumper.

  • Sequel::SQL::PlaceholderLiteralString is now a GenericExpression subclass, allowing you to treat it like most other Sequel expression objects:

    '(a || ?)'.lit(:b).like('Test%')
    # ((a || b) LIKE 'Test%')
  • Sequel now supports the bitwise shift operators (<< and >>) on Microsoft SQL Server by emulating them.

  • Sequel now supports most bitwise operators (&, |, ^, <<, >>) on H2 by emulating them. The bitwise complement operator is not yet supported.

  • Sequel now logs the SQL queries that are sent when connecting to MySQL.

  • If a plugin cannot be loaded, Sequel now gives a more detailed error message.

Backwards Compatibility

  • Array#sql_array and the Sequel::SQL::SQLArray class are now considered deprecated. Use the Array#sql_value_list and the Sequel::SQL::ValueList class instead. SQLArray is now just an alias for ValueList, but it now is an Array subclass instead of a Sequel::SQL::Expression subclass.

  • Using the ruby bitwise xor operator (^) on PostgreSQL now uses PostgreSQL’s bitwise xor operator (#) instead of PostgreSQL’s exponentiation operator (^). If you want exponentiation, use the power function.

  • Using the ruby bitwise complement operator (~) on MySQL now returns a signed integer instead of an unsigned integer, for better compatibility with other databases.

  • Using nil as a case expression value (the 2nd argument to Hash#case and Array#case) will now use NULL as the case expression value, instead of omitting the case expression value:

    # 3.12.0
    {1=>2}.case(0, nil)
    # 3.13.0
    {1=>2}.case(0, nil)

    In general, you would never use nil explicitly, but the new behavior makes more sense if you have a variable that might be nil:

    parent_id = Node[1].parent_id
    {1=>2}.case(0, parent_id)

    If parent_id IS NULL/nil, then previously Sequel would have generated unexpected SQL. If you don’t want a case expression value to be used, do not pass a second argument to case.

  • Some internal transaction methods now take an optional options hash, so if you have a custom adapter, you will need to make changes.

  • Some internal association methods now take an optional options hash.

  • Some Rakefile task names were modified in the name of consistency:

    spec_coverage -> spec_cov
    integration -> spec_integration
    integration_cov -> spec_integration_cov