sequel 3.27.0 → 3.28.0

data/CHANGELOG

@@ -1,3 +1,99 @@
+=== 3.28.0 (2011-10-03)
+
+* Add firebird jdbc subadapter (jeremyevans)
+
+* Add SQLTime.create method for easier creation of SQLTime instances (jeremyevans)
+
+* Make Dataset#with_pk use a qualified primary key, so it works correctly on joined datasets (jeremyevans)
+
+* Support the :limit association option when using eager_graph (jeremyevans)
+
+* Fix eager loading via eager_graph of one_to_one associations that match multiple associated objects and use order to pick the first one (jeremyevans)
+
+* Make after_load association hooks apply when using eager_graph (jeremyevans)
+
+* Make Dataset#with_sql treat a symbol as a first argument as a method name to call to get the SQL (jeremyevans)
+
+* Make Dataset #delete, #insert, #update return array of plain hashes if block not given and Dataset#returning is used (jeremyevans)
+
+* Allow Dataset #map, #to_hash, #select_map, #select_order_map, and #select_hash to take arrays of columns instead of single columns (jeremyevans)
+
+* Make Dataset #delete, #insert, #update yield plain hashes to a block if Dataset#returning is used (jeremyevans)
+
+* Add Dataset#returning for setting the columns to return in INSERT/UPDATE/DELETE statements, used by PostgreSQL 9.1 (jeremyevans)
+
+* Support WITH clause in INSERT/UPDATE/DELETE on PostgreSQL 9.1+ (jeremyevans)
+
+* Add Database#copy_table for PostgreSQL COPY support when using the postgres adapter with pg (jeremyevans)
+
+* Support CREATE TABLE IF NOT EXISTS on PostgreSQL 9.1+ (jeremyevans)
+
+* Add support for Sequel::Model.default_eager_limit_strategy to set the default :eager_limit_strategy for *_many associations (jeremyevans)
+
+* Add support for an :eager_limit_strategy => :correlated_subquery value for limiting using correlated subqueries (jeremyevans)
+
+* Allow use of a dataset that uses the emulated offset support on MSSQL and DB2 in an IN subquery by using a nested subquery (jeremyevans)
+
+* Allow use of a dataset that uses LIMIT in an IN subquery on MySQL by using a nested subquery (jeremyevans)
+
+* Work around serious ActiveSupport bug in Time.=== that breaks literalization of Time values (jeremyevans)
+
+* Speed up SQL operator methods by using module_eval instead of define_method (jeremyevans)
+
+* Support sql_(boolean,number,string) methods on ComplexExpressions, allowing you do to (x + 1).sql_string + 'a' for (x + 1) || 'a' (jeremyevans)
+
+* Don't disallow SQL expression creation based on types, leave that to the database server (jeremyevans)
+
+* Make :column [&|] 1 use an SQL bitwise [&|] expression instead of a logical (AND|OR) expression (jeremyevans)
+
+* Make :column + 'a' use an SQL string concatenation expression instead of an addition expression (jeremyevans)
+
+* Fix :time typecasting from Time to SQLTime for fractional seconds on ruby 1.9 (jeremyevans)
+
+* Have Dataset#select_append check supports_select_all_and_column? and select all from all FROM and JOIN tables if no columns selected (jeremyevans)
+
+* Add Dataset#supports_select_all_and_column? for checking if you can do SELECT *, column (jeremyevans)
+
+* Add support for an :eager_limit_strategy => :window_function value for limiting using window functions (jeremyevans)
+
+* Add support for an :eager_limit_strategy => :distinct_on value for one_to_one associations for using DISTINCT ON (jeremyevans)
+
+* Add support for an :eager_limit_strategy association option, for manual control over how limiting is done (jeremyevans)
+
+* Add Dataset#supports_ordered_distinct_on? for checking if the dataset can use distinct on while respecting order (jeremyevans)
+
+* Add support for the association :limit option when eager loading via .eager for *_many associations (jeremyevans)
+
+* Add db2 jdbc subadapter (jeremyevans)
+
+* Fix the db2 adapter so it actually works (jeremyevans)
+
+* Add ibmdb adapter for accessing DB2 (roylez, jeremyevans)
+
+* Add much better support for DB2 databases (roylez, jeremyevans)
+
+* Handle SQL::AliasedExpressions and SQL::JoinClauses in Dataset#select_all (jeremyevans)
+
+* Speed up type translation slightly in mysql, postgres, and sqlite adapters (jeremyevans)
+
+* Add Dataset#supports_cte_in_subqueries? for checking whether database supports WITH in subqueries (jeremyevans)
+
+* Allow Model.set_dataset to accept Sequel::LiteralString arguments as table names (jeremyevans)
+
+* Association :after_load hooks in lazy loading are now called after the associated objects have been cached (jeremyevans)
+ 
+* Emulate handling of extract on MSSQL, using datepart (jeremyevans)
+
+* Emulate handling of extract on SQLite, but you need to set Database#use_timestamp_timezones = false (jeremyevans)
+
+* Abstract handling of ComplexExpressionMethods#extract so that it can work on databases that don't implement extract (jeremyevans)
+
+* Emulate xor operator on SQLite (jeremyevans)
+
+* Add Dataset#supports_where_true? for checking if the database supports WHERE true (or WHERE 1 if 1 is true) (jeremyevans)
+
+* Fix eager loading via eager of one_to_one associations that match multiple associated objects and use order to pick the first one (jeremyevans)
+
 === 3.27.0 (2011-09-01)
 
 * Add support for native prepared statements to the tinytds adapter (jeremyevans)

data/README.rdoc

@@ -12,8 +12,8 @@ toolkit for Ruby.
   two-phase commit, transaction isolation, master/slave
   configurations, and database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, DataObjects,
-  DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase,
-  Oracle, PostgreSQL, SQLite3, Swift, and TinyTDS.
+  DB2, DBI, Firebird, IBM_DB, Informix, JDBC, MySQL, Mysql2, ODBC,
+  OpenBase, Oracle, PostgreSQL, SQLite3, Swift, and TinyTDS.
 
 == Resources
 

data/Rakefile

@@ -128,7 +128,7 @@ begin
   spec_with_cov.call("spec_plugin", Dir["spec/extensions/*_spec.rb"], "Run extension/plugin specs")
   spec_with_cov.call("spec_integration", Dir["spec/integration/*_test.rb"], "Run integration tests")
   
-  %w'postgres sqlite mysql informix oracle firebird mssql'.each do |adapter|
+  %w'postgres sqlite mysql informix oracle firebird mssql db2'.each do |adapter|
     spec_with_cov.call("spec_#{adapter}", ["spec/adapters/#{adapter}_spec.rb"] + Dir["spec/integration/*_test.rb"], "Run #{adapter} specs")
   end
 rescue LoadError

data/doc/association_basics.rdoc

@@ -1518,3 +1518,51 @@ associations depends on another plugin that defines instance methods of
 the same name.  In that case, the instance methods of the dependent
 plugin would override the association methods created by the main
 plugin.
+
+==== :eager_limit_strategy
+
+This setting determines what strategy to use for loading the associations
+that use the :limit setting to limit the number of returned records. You
+can't use LIMIT directly, since you want a limit for each associated
+record, not a LIMIT on the number of records returned by the dataset.
+
+By default, no strategy is used for one_to_one associations, and
+the :ruby strategy is used for *_many associations, which does a simple
+array slice after loading the associated records.  That doesn't provide
+a performance advantage, since all records are still loaded from the
+database, but it at least makes sure the cached records are accurately
+limited as they would be in the lazy load case.
+
+The reason no strategy is used by default for one_to_one associations
+is that none is needed for a true one_to_one association (since there
+is only one associated record per current record).  However, if you are
+using a one_to_one association where the relationship is really one_to_many,
+and using an order to pick the first matching row, then if you don't
+specify an :eager_limit_strategy option, you'll be loading all related
+rows just to have Sequel ignore all rows after the first.  By using a
+strategy to change the query to only return one associated record per
+current record, you can get much better database performance.
+
+You can set a value of +true+ for this option to have Sequel select what
+it thinks is the best way of limiting the records for your database.  You
+can also specify a symbol to manually choose a strategy.  The available
+strategies are:
+
+:distinct_on :: Uses DISTINCT ON to ensure only the first matching record
+                is loaded (one_to_one associations only). This is used by
+                default on PostgreSQL.
+:window_function :: Uses window functions if the database supports it.
+                    This is used by default on databases that support window
+                    functions.
+:correlated_subquery :: Uses a correlated subquery to get the information.
+                        This is never used by default as if you aren't careful,
+                        it can result in pathologically long running times
+                        This will not work correctly for association where
+                        the associated table has a composite primary key if
+                        the database doesn't support using IN
+                        with multiple columns.  This will also not work on MySQL
+                        because MySQL has problems using IN with a correlated
+                        subquery that contains a limit.
+:ruby :: Uses ruby array slicing to emulate database limiting (*_many
+         associations only).  This is the default if the database doesn't
+         support window functions.

data/doc/opening_databases.rdoc

@@ -46,6 +46,13 @@ unless the first argument is a hash. So the following statements are equivalent
   DB = Sequel.postgres('blog', :host=>'localhost', :user=>'user', :password=>'password')
   DB = Sequel.postgres(:host=>'localhost', :user=>'user', :password=>'password', :database=>'blog')
 
+Note that using an adapter method forces the use of the specified adapter, not a database type, even
+though some adapters have the same name as the database type.  So if you
+want to connect to SQLite, for example, you can do so using the sqlite, do, dbi, jdbc, odbc, and swift adapters.
+If you want to connect to SQLite on JRuby using the jdbc adapter, you should not use <tt>Sequel.sqlite</tt>
+for example, as that uses the C-based sqlite3 gem. Instead, the <tt>Sequel.jdbc</tt> would be appropriate (though
+as mentioned below, using <tt>Sequel.connect</tt> is recommended instead of <tt>Sequel.jdbc</tt>). 
+
 == Passing a block to either method
 
 Both the Sequel.connect method and the specialized adapter methods take a block.  If you
@@ -145,10 +152,8 @@ the sqlite section below for details.
 
 Requires: db2/db2cli
 
-I'm not even sure exactly how this works, or if it works at all (I've never heard from
-anyone who attempted to use it).  It uses the SQL_HANDLE_DBC constant to
-get a handle, and respects the :database, :user, and :password options.  It doesn't
-appear to respect the :host or :port options.
+This is the older DB2 adapter.  It's recommended you try the ibmdb adapter
+instead for new DB2 work, as it is better supported.
 
 === dbi 
 
@@ -201,6 +206,13 @@ Requires: fb (using code at http://github.com/wishdev/fb)
 
 Does not support the :port option.
 
+=== ibmdb
+
+requires 'ibm_db'
+
+This connects to DB2 using IBM_DB.  This is the recommended adapter if you are
+using a C-based ruby to connect to DB2.
+
 === informix 
 
 Does not support the :host or :port options.  Depending on the configuration of your server
@@ -221,7 +233,7 @@ Requires: java
 Houses Sequel's JDBC support when running on JRuby.
 Support for individual database types is done using sub adapters.
 There are currently subadapters for PostgreSQL, MySQL, SQLite, H2,
-Oracle, MSSQL, JTDS, and AS400.  All except Oracle, MSSQL, and AS400 can load the
+Oracle, MSSQL, JTDS, AS400, and DB2.  All except Oracle, MSSQL, AS400, and DB2 can load the
 jdbc-* gem, for those you need to have the .jar in your CLASSPATH
 or load the Java class manually before calling Sequel.connect.
 
@@ -262,6 +274,8 @@ The following additional options are supported:
 
 === mysql 
 
+Requires: mysqlplus (or mysql if mysqlplus is not available)
+
 The MySQL adapter does not support the pure-ruby MySQL adapter that used to ship with
 ActiveRecord, it requires the native adapter.
 
@@ -278,6 +292,12 @@ The following additional options are supported:
 * :read_timeout - Set the timeout in seconds for reading back results to a query.
 * :connect_timeout - Set the timeout in seconds before a connection attempt is abandoned.
 
+=== mysql2
+
+This is a newer MySQL adapter that does typecasting in C, so it is often faster than the
+mysql adapter.  Supports the same additional options as the mysql adapter, except for :compress, and uses
+:timeout instead of :read_timeout and :connect_timeout.
+
 === odbc 
 
 The ODBC adapter allows you to connect to any database with the appropriate ODBC drivers installed.  
@@ -316,6 +336,8 @@ The following additional options are supported:
 
 === sqlite
 
+Requires: sqlite3
+
 As SQLite is a file-based database, the :host and :port options are ignored, and
 the :database option should be a path to the file.
 
@@ -353,6 +375,8 @@ Examples:
 
 === tinytds
 
+Requires: tiny_tds
+
 Because the underscore is not a valid character in a URI schema, the adapter
 is named tinytds instead of tiny_tds.  The connection options are passed directly
 to tiny_tds, except that the tiny_tds :username option is set to

data/doc/prepared_statements.rdoc

@@ -5,6 +5,7 @@ database you are using, the Sequel prepared statement/bound variable API remains
 the same.  There is native support for prepared statements/bound variables on
 the following adapters:
 
+* ibmdb (prepared statements only)
 * jdbc
 * mysql (prepared statements only)
 * mysql2 (prepared statements only)

data/doc/release_notes/3.28.0.txt

@@ -0,0 +1,304 @@
+= New Adapter Support
+
+* Sequel now has much better support for the DB2 database.
+
+* An ibmdb adapter has been added, and is the recommended adapter to
+  to use if you want to connect to DB2 from MRI.
+
+* A jdbc db2 subadapter has been added, allowing good DB2 support on
+  JRuby.
+
+* The db2 adapter has been cleaned up substantially, and now works
+  well, but it is still recommended that you switch to ibmdb if you
+  are using the db2 adapter.
+
+* The firebird adapter has been split into shared and specific parts,
+  and quite a few fixes were made to it.
+
+* A jdbc firebird subadapter has been added, allowing connection to
+  firebird databases from JRuby.
+
+= New PostgreSQL 9.1 Features
+
+* Dataset#returning has been added for using the RETURNING clause on
+  INSERT/UPDATE/DELETE queries.  RETURNING allows such queries to
+  return results in much the same way as a SELECT query works.
+  When Dataset#returning is used, Dataset #insert, #update, and
+  #delete now accept a block that is passed to Dataset #fetch_rows 
+  which is yielded plain ruby hashes for each row inserted, updated,
+  or deleted.  If Dataset#returning is used and a block is not given
+  to those methods, those methods will return an array of plain hashes
+  for all rows inserted, updated, and deleted.
+
+* Dataset#with_sql now treats a symbol as a first argument as a method
+  name to call to get the SQL.  The expected use case for this is with
+  Dataset#returning and insert/update/delete:
+    
+    DB[:items].
+     returning(:id).
+     with_sql(:update_sql, :b => :b + 1).
+     map(:id)
+    
+  Basically, it makes it more easily to statically set the
+  insert/update/delete SQL, and then be able to use the full
+  dataset API for returning results.  As mentioned above, using
+  Dataset#returning with #insert, #update, and #delete yields plain
+  hashes, so if you want to have the row_proc applied (e.g. you are
+  using models), you need to use this method instead, since you can
+  then call #each or #all to make sure the row_proc is called on all
+  returned rows.
+
+* Dataset#with (common table expressions) now affects
+  INSERT/UPDATE/DELETE queries.
+
+* Database#create_table? now uses CREATE TABLE IF NOT EXISTS on
+  PostgreSQL 9.1.
+
+= Other New Features
+
+* The :limit option is now respected when eager loading via either
+  eager or eager_graph.  By default, Sequel will just do an array
+  slice of the resulting ruby array, which gets the correct answer,
+  but does not offer any performance improvements.  Sequel also
+  offers a new :eager_limit_strategy option for using more advanced
+  query types that only load the related records from the database.
+  The available values for the :eager_limit_strategy option are:
+
+    :window_function: This uses the row_number window function
+      partitioned by the related key fields.  It can only be used
+      on databases that support window functions (PostgreSQL 8.4+,
+      Microsoft SQL Server 2005+, DB2).
+    :correlated_subquery: This uses a correlated subquery that is
+      limited.  It works on most databases except MySQL and DB2.
+
+  You can provide a value of true as the option to have Sequel
+  pick a strategy to use. Sequel will never use a correlated
+  subquery for true, since in some cases it can perform worse than
+  loading all related records and doing the array slice in ruby.
+
+  If you want to enable an eager_limit_strategy globally, you can
+  set Sequel::Model.default_eager_limit_strategy to a value, and
+  all associations that use :limit will default to using that
+  strategy.
+
+* one_to_one associations that do not represent true one-to-one
+  database relationships, but represent one-to-many relationships
+  where you are only returning the first object based on a given
+  order are also now handled correctly when eager loading.
+  Previously, eager loading such associations resulted in the last
+  matching object being associated instead of the first matching
+  object being associated.
+
+  You can also use an :eager_limit_strategy for one_to_one
+  associations.  In addition to the :window_function and
+  :correlated_subquery values, there is also a :distinct_on value
+  that is available on PostgreSQL for using DISTINCT ON, which is
+  the fastest strategy if you are using PostgreSQL.
+
+* Dataset#map, #to_hash, #select_map, #select_order_map, and
+  #select_hash now accept arrays of symbols, and if given arrays
+  of symbols, use arrays of results.  For example:
+
+    DB[:items].map([:id, :name])
+    # => [[1, 'foo'], [2, 'bar'], ...]
+    DB[:items].to_hash([:id, :foo_id], [:name, :bar_id])
+    # => {[1, 3]=>['foo', 5], [2, 4]=>['bar', 6], ...}
+
+* For SQL expression objects where Sequel cannot deduce the type
+  of the object, it now will consider the type of the argument
+  when a &, |, or + operator is used.  For example:
+
+    :x & 1
+
+  Previously, this did "x AND 1", now it does "x & 1".  Using a
+  logical operator on an integer doesn't make sense, but it's
+  possible people did so if the database uses 1/0 for true/false.
+  Likewise:
+
+    :x + 'foo'
+
+  Previously, this did "x + 'foo'" (addition), now it does
+  "x || 'foo'" (string concatenation).
+
+* The sql_string, sql_number, and sql_boolean methods are now
+  available on SQL::ComplexExpressions, so you can do:
+
+    (:x + 1).sql_string + ' foos'
+    # (x + 1) || ' foos'
+
+  Previously, there was not an easy way to generate such SQL
+  expressions.
+
+* :after_load association hooks are now applied when using
+  eager_graph.  Previously, they were only applied when using
+  eager, not when using eager_graph.
+
+* Database#copy_table has been added to the postgres adapter if pg
+  is used as the underlying driver.  It allows you to get very
+  fast exports of table data in text or CSV format.  It also
+  accepts datasets, allowing fast exports of arbitrary queries
+  in text or CSV format.
+
+* SQL extract support (:timestamp.extract(:year)) is now emulated
+  on the databases that don't natively support it, such as SQLite,
+  Microsoft SQL Server, and DB2.  At least the following values are
+  supported for extraction: :year, :month, :day, :hour, :minute,
+  and :second.
+
+* The bitwise XOR operator is now emulated on SQLite.  Previously,
+  attempting to use it would cause the database to raise an error.
+
+* A Database#use_timestamp_timezones accessor has been added on
+  SQLite.  This allows you to turn off the use of timezones in
+  timestamps by setting the value to false.  This is necessary if you
+  want you want to use the SQLite datetime functions, or the new
+  ability to emulate extract.
+    
+  Note that this setting does not affect the current database
+  content.  To convert old databases to the new format, you'll
+  have to resave all rows that have timestamps.
+
+  At some point in the future, Sequel may default to not using
+  timezones in timestamps by default on SQLite, so if you would
+  like to rely on the current behavior, you should set this
+  accessor to true now.
+
+* Sequel now works around bugs in MySQL when using a subselect with
+  a LIMIT by using a nested subselect.
+
+* Sequel now works around issues in Microsoft SQL Server and DB2 when
+  using a subselect with IN/NOT IN that uses the emulated offset
+  support.
+
+* The jdbc adapter now returns java.sql.Clob objects as
+  Sequel::SQL::Blobs.
+
+* Sequel now considers database clob types as the :blob schema type.
+
+* Sequel::SQLTime.create has been added for more easily creating
+  instances:
+
+    Sequel::SQLTime.create(hour, minute, second, usec)
+
+* Dataset#select_all now accepts SQL::AliasedExpression and
+  SQL::JoinClause arguments and returns the appropriate
+  SQL::ColumnAll value that selects all columns from the related
+  table.
+
+* Model.set_dataset now accepts Sequel::LiteralString objects that
+  represent table names.  This usage is not encouraged except in
+  rare cases such as using a set returning function in PostgreSQL.
+
+* Dataset#supports_cte? now takes an optional argument specifying the
+  type of query (:insert, :update, :delete, :select).  It defaults to
+  :select.
+
+* Dataset#supports_returning? has been added.  It requires an
+  argument specifying the type of query (:insert, :update, or
+  :delete).
+
+* Dataset#supports_cte_in_subqueries? has been added for checking
+  for support for this ability.  Apparently, only PostgreSQL
+  currently supports this.  For other adapters that support CTEs but
+  not in subqueries, if a subquery with a CTE is used in a JOIN, the
+  CTE is moved from the subquery to the main query.
+
+* Dataset#supports_select_all_and_column has been added for seeing
+  if "SELECT *, foo ..." style queries are supported.  This is false
+  on DB2, which doesn't allow such queries.  When it is false, using
+  select_append on a dataset that doesn't specifically select columns
+  will now change the query to do "SELECT table.*, foo ..." instead,
+  working around the limitation on DB2.
+
+* Dataset#supports_ordered_distinct_on? has been added.  Currently,
+  this is only true on PostgreSQL.  MySQL can emulate DISTINCT ON
+  using GROUP BY, but it doesn't respect ORDER BY, so it some
+  cases it cannot be used equivalently.
+
+* Dataset#supports_where_true? has been added for checking for support
+  of WHERE TRUE (or WHERE 1 if 1 is true).  Not all databases support
+  using such a construct, and on the databases that do not, you have
+  to use WHERE (1 = 1) or something similar.
+
+= Other Improvements
+
+* Sequel 3.27.0 was negatively affected by a serious bug in
+  ActiveSupport's Time.=== that has still not been fixed, which
+  broke the literalization of Time objects.  In spite of the bad
+  precedent it sets, Sequel now avoids using Time.=== on a
+  subclass of Time to work around this ActiveSupport bug.
+
+* Dataset#with_pk now uses a qualified primary key instead of an
+  unqualified primary key, which means it can now be used correctly
+  after joining to a separate table.
+
+* Association after_load hooks when lazy loading are now called
+  after the association has been loaded, which allows them to change
+  which records are cached.  This makes the lazy load case more
+  similar to the eager load case.
+
+* The metaprogrammatically created methods that implement Sequel's
+  DSL support have been made significantly faster by using
+  module_eval instead of define_method.
+
+* The type translation in the postgres, mysql, and sqlite adapters
+  has been made faster by using Method objects that result in more
+  direct processing.
+
+* Typecasting values for time columns from Time values to
+  Sequel::SQLTime values now correctly handles fractional seconds on
+  ruby 1.9.
+
+= Backwards Compatibility
+
+* Dataset#insert_returning_sql has been changed to a private method
+  in the PostgreSQL and Firebird adapters, and it operates
+  differently than it did previously.  The private
+  #insert_returning_pk_sql and #insert_returning_select_sql methods
+  have been removed.
+
+* Dataset#with_pk no longer does some defensive checking for misuse of
+  primary keys (e.g. providing a composite key when the model uses
+  a single key).  Previously, Sequel would raise an Error
+  immediately, now such behavior is undefined, with the most likely
+  behavior being the database raising an Error.
+
+* The :alias_association_type_map and :alias_association_name_map
+  settings have been removed from the :eager_graph dataset option,
+  in favor of just storing the related association reflection.
+
+* The internals of the db2 adapter have changed substantially, if you
+  were relying on some of the private methods defined in it, you will
+  probably have to modify your code.
+
+* The firebird adapter was substanially modified, specifically parts
+  related to insert returning autogenerated primary key values, so if
+  you were previously using the adapter you should probably take more
+  care than usual when testing your upgrade.  
+
+* The Dataset::WITH_SUPPORTED constant has been removed.
+
+* The Dataset#supports_cte? method now accepts an optional argument.
+  If you overrode this method, your overridden method now must
+  accept an optional argument.
+
+* If you were previously doing:
+
+    :x & 1
+
+  and wanting "x AND 1", you have to switch to:
+
+    :x.sql_boolean & 1
+
+  Likewise, if you were previously doing:
+
+    :x + 'foo'
+
+  and wanting "x + 'foo'", you need to switch to:
+
+    :x.sql_number + 'foo'
+
+* Sequel no longer does defensive type checking in the SQL expression
+  support, as it was often more strict than the database and would
+  not allow the creation of expressions that were valid for the
+  database.