2.6.0.txt

doc/release_notes/2.6.0.txt
Last Update: 2013-11-10 14:46:11 -0800

New Features


  • Schema parsing was refactored, resulting in a huge speedup when using MySQL. MySQL now uses the DESCRIBE statement instead of the INFORMATION_SCHEMA. PostgreSQL now uses the pg_* system catalogs instead of the INFORMATION schema.

  • The schema information now includes the :primary_key field. Models now use this field to automatically determine the primary key for a table, so it no longer needs to be specified explicitly. Models even handle the composite primary key case.

  • The raise_on_typecast_failure switch was added, with it being true by default (so no change in behavior). This allows the user to silently ignore errors when typecasting fails, at the global, class, and instance levels.

    Sequel::Model.raise_on_typecast_failure = false # Global
    Artist.raise_on_typecast_failure = true # Class
    artist = Artist.new
    artist.raise_on_typecast_failure = false # Instance
    
    Album.raise_on_typecast_failure = true
    Album.new(:numtracks=>'a') # => raises Sequel::Error::InvalidValue
    Album.raise_on_typecast_failure = false
    Album.new(:numtracks=>'a') # => #<Album @values={:numtracks=>"a"}>
  • Associations' orders are now respected when eager loading via eager_graph. Sequel will qualify the columns in the order with the alias being used, so you can have overlapping columns when eager loading multiple associations.

    Artist.one_to_many :albums, :order=>:name
    Album.one_to_many :tracks, :order=>:number
    Artist.order(:artists__name).eager_graph(:albums=>:tracks).sql
    # => ... ORDER BY artists.name, albums.name, tracks.number
  • The support for CASE expressions has been enhanced by allowing the use of an optional expression:

    {1=>2}.case(0, :x)
    # => CASE x WHEN 1 THEN 2 ELSE 0 END
    [[:a, 1], [:b, 2], [:c, 3]].case(4, :y)
    # => CASE y WHEN a THEN 1 WHEN b THEN 2 WHEN c THEN 3 ELSE 4 END

    Previously, to get something equivalent to this, you had to do:

    {{:x=>1}=>2}.case(0)
    # => CASE WHEN (x = 1) THEN 2 ELSE 0 END
    [[{:y=>:a}, 1], [{:y=>:b}, 2], [{:y=>:c}, 3]].case(4)
    # => CASE WHEN (y = a) THEN 1 WHEN (y = b) THEN 2 WHEN (y = c)
         THEN 3 ELSE 4 END
  • You can now change the NULL/NOT NULL value of an existing column using the set_column_allow_null method.

    # Set NOT NULL
    DB.alter_table(:artists){set_column_allow_null :name, false}
    # Set NULL
    DB.alter_table(:artists){set_column_allow_null :name, true}
  • You can now get the schema information for a table in a non-public schema in PostgreSQL using the implicit :schema__table syntax. Before, the :schema option had to be given explicitly to Database#schema. This allows models to get schema information for tables outside the public schema.

  • Transactions are now supported on MSSQL.

  • Dataset#tables now returns all tables in the database for MySQL databases accessed via JDBC.

  • Database#drop_view can now drop multiple views at once.

Other Improvements


  • The SQLite adapter now respects the Sequel.datetime_class option for timestamp and datetime columns.

  • Adding a unique constraint no longer explicity creates a unique index. If you want a unique index, use index :unique=>true.

  • If no language is specified when creating a full text index on PostgreSQL, the simple language is assumed.

  • Errors when typecasting fails are now Sequel::Error::InvalidValue instead of the more generic Sequel::Error.

  • Specifying constraints now works correctly for all types of arguments. Previously, it did not work unless a block or interpolated string were used.

  • Loading an association with the same name as a table in the FROM clause no longer causes an error.

  • When eagerly loading many_to_one associations where no objects have an associated object, the negative lookup is now cached.

  • String keys can now be used with Dataset#multi_insert, just like they can be used for Dataset#insert.

  • Dataset#join_table now generates the correct SQL when doing the first join to a dataset where the first source is a dataset, when an unqualified column is used in the conditions.

  • Cascading associations after *_to_many associations can now be eagerly loaded via eager_graph.

  • Eagerly loading *_to_many associations that are cascaded behind a many_to_one association now have their duplicates removed if a cartesian product join is done.

  • The SQLite adapter now uses string literals in all of the AS clauses. While the SQL standard specifies that identifiers should be used, SQLite documentation explicitly states that string literals are expected (though it generally works with identifiers by converting them implicitly).

  • Database methods that modify the schema now remove the cached schema entry.

  • The hash keys that Database#schema returns when no table is requested are now always supposed to be symbols.

  • The generation of SQL for composite foreign keys on MySQL has been fixed.

  • A schema.rdoc file was added to the documentation explaining the various parts of Sequel related to schema generation and modification and how they interact (sequel.rubyforge.org/rdoc/files/doc/schema_rdoc.html).

  • The RDoc template for the website was changed from the default template to the hanna template.

Backwards Compatibility


  • The :numeric_precision and :max_chars schema entries have been removed. Use the :db_type entry to determine this information, if available.

  • The SQLite adapter used to always return Time instances for timestamp types, even if Sequel.datetime_class was DateTime. For datetime types it always returned a DateTime instance. It now returns an instance of Sequel.datetime_class in both cases.

  • It's possible that the including of associations' orders when eager loading via eager_graph could cause problems. You can use the :order_eager_graph=>false option to not use the :order option when eager loading via :eager_graph.

  • There were small changes in SQL creation where the AS keyword is now used explicitly. These should have no effect, but could break tests for explicit SQL.