asana2flowdock 1.0.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/release_notes/3.35.0.txt

@@ -0,0 +1,144 @@
+= New Features
+
+* A dirty plugin has been added, which saves the initial value of
+  the column when the column is changed, similar to
+  ActiveModel::Dirty:
+
+    artist.name                   # => 'Foo'
+    artist.name = 'Bar'
+    artist.initial_value(:name)   # 'Foo'
+    artist.column_change(:name)   # ['Foo', 'Bar']
+    artist.column_changes         # {:name => ['Foo', 'Bar']}
+    artist.column_changed?(:name) # true
+    artist.reset_column(:name)
+    artist.name                   # => 'Foo'
+    artist.column_changed?(:name) # false
+    artist.update(:name=>'Bar')
+    artist.column_changes         # => {}
+    artist.previous_changes       # => {:name=>['Foo', 'Bar']}
+
+* Database#create_table now respects an :as option to create a
+  database based on the results of a query.  The :as option value
+  should either be an SQL string or a dataset.
+
+    DB.create_table(:new_foos, :as=>DB[:foos].where(:new=>true))
+
+* The json_serializer and xml_serializer plugins can now serialize
+  arbitrary arrays of model objects by passing an :array option
+  to the to_json class method.  This works around an issue in
+  ruby's JSON library where Array#to_json does not pass arguments
+  given to it to the members of the array.
+
+    Artist.to_json(:array=>[Artist[1]], :include=>:albums)
+
+* You can now use the % (modulus) operator in the same way you
+  can use the bitwise operators in Sequel:
+
+    :column.sql_number % 1 # (column % 1)
+
+* On PostgreSQL, you can now provide :only, :cascade, and :restart
+  options to Dataset#truncate to use ONLY, CASCADE, and
+  RESTART IDENTITY.  Additionally, you can now truncate multiple
+  tables at the same time:
+
+    DB.from(:table1, :table2).truncate(:cascade=>true)
+
+* The :index option when creating columns in the schema generator
+  can now take a hash of index options:
+
+    DB.create_table(:foo){Integer :bar, :index=>{:unique=>true}}
+
+* A Database#cache_schema accessor has been added, it can be set
+  to false to have the Database never cache schema results.  This
+  can be useful in Rails development mode, so that you don't need to
+  restart a running server to have models pick up the new schema.
+
+* Database#log_exception has been added for easier instrumentation.
+  It is called with the exception and SQL query string for all
+  queries that raise an exception.
+
+* The Sequel.migration DSL now has a transaction method that forces
+  transaction use for the given migration.
+
+= Other Improvements
+
+* Many theoretical thread-safety issues have been fixed for ruby
+  implementations that don't use a global interpreter lock.
+  Previously, Sequel relied on MRI's global interpreter lock for
+  part of its thread safety, now it does manually locking in more
+  places to avoid thread-safety issues on JRuby (and other ruby
+  implementations without a global interpreter lock).
+
+  No Sequel user ever reported a production error related to the
+  previous thread-safety issues, and most of the issues fixed
+  were so difficult to hit that even tests specifically designed
+  to raise errors were unable to do so.
+
+* Sequel.single_threaded = true now disables the mutex
+  synchronization that enforces thread safety for additional
+  performance in single threaded mode.
+
+* Sequel's migrators now only attempt to use transactions by
+  default if the underlying database supports transactional DDL.
+  SQLite does support transactional DDL, but Sequel will not
+  use transactions for SQLite migrations as it causes issues
+  when emulating alter_table operations for tables with foreign
+  keys.
+
+* Errors that occur when rolling back database transactions are
+  now handled correctly.  Previously, the underlying exception was
+  raised, it wasn't correctly wrapped in a Sequel::DatabaseError,
+  and if it was due to a database disconnection, the connection
+  wasn't removed from the pool.
+
+* Sequel no longer sets ruby instance variables on java objects,
+  fixing warnings on JRuby 1.7 and attempting to be forward
+  compatible with JRuby 2.0.
+
+* Sequel now uses date and timestamp formats that are multilanguage
+  and not DATEFORMAT dependent on Microsoft SQL Server.
+
+* Sequel now correctly escapes blackslash-carriage return-line feed
+  on Microsoft SQL Server.
+
+* Parsing the column default values in the oracle adapter no longer
+  requires database superuser privileges.
+
+* Sequel now correctly handles parsing schema for tables in other
+  databases on MySQL.  Previously, it would always look in the
+  current database.
+
+* Sequel no longer doubles backslashes in strings by default.  It
+  now only does so on MySQL, since that is the only database that
+  appears to use backslashes for escaping.  This fixes issues with
+  backslashes being doubled on some of the less commonly used
+  adapters.
+
+* The pg_auto_parameterize extension now works correctly when
+  using cursors.
+
+* Dataset#truncate now raises an Error if you attempt to do so
+  on a dataset that uses HAVING.  Previously, it only checked for
+  WHERE.
+
+* The schema dumper now recognized the identity type.
+
+= Backwards Compatibility
+
+* Association reflections now store cached information in a
+  separate subhash due to the thread-safety changes.  Any code
+  accessing an association reflection should always call the
+  related method to get the cached data instead of checking
+  for a specific location in the hash.
+
+* Association reflection internals for many_through_many associations
+  changed significantly, any code that accesses the edge information
+  in the reflection will need to be changed to use the new methods
+  instead of accessing the old values directly.
+
+* The features deprecated in 3.34.0 have now been removed:
+  * Ruby <1.8.7 support
+  * PostgreSQL <8.2 support
+  * Dataset#disable_insert_returning on PostgreSQL
+  * Array#all_two_pairs? and #sql_expr_if_all_two_pairs
+  

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/release_notes/3.36.0.txt

@@ -0,0 +1,245 @@
+= New Features
+
+* An eager_each plugin has been added, which automatically makes
+  eagerly loaded datasets do eager loading if you call #each (or
+  another Enumerable method) instead of #all.  By default, if you
+  call #each on an eager dataset, it will not do eager loading,
+  and if you call #each on an eager_graph dataset, you will
+  get plain hashes with columns from all joined tables instead of
+  model objects.  With this plugin, #each on both eager and
+  eager_graph datasets will do eager loading.
+
+* The nested attributes plugin now supports composite primary keys
+  in associated records.  Additionally, it now deals better with
+  natural primary keys in associated records.  There is a new
+  :unmatched_pk option that can be set to :create if you want to
+  create new associated records when the input hash contains
+  primary key information that doesn't match one of the existing
+  associated objects.
+
+  The nested attributes plugin now also supports a :transform option.
+  If given, this option is called with the parent object and the
+  input hash given for each associated record passed into the
+  nested atttributes setter.  The callable should return the hash
+  of attributes to use.
+
+* Model#from_json in the json_serializer plugin now takes an options
+  hash and recognizes the :fields option.  If the :fields option is
+  given, it should be an array of field names, and set_fields is
+  called with the array instead of using set.  This allows you to
+  easily filter which fields in the hash are set in the model
+  instance.  The entire options hash is also passed to set_fields
+  if :fields is present, so you can additionally use the :missing =>
+  :raise or :missing => :skip options that set_fields supports.
+
+* The Dataset#to_json method in the json_serializer plugin now
+  respects :root=>:collection and :root=>:instance options.  If
+  :root=>:collection is given, only the collection is wrapped in a
+  hash, and if :root=>:instance is given, only the instances are
+  wrapped in a hash.  For backwards compatibility, both the
+  instances and collection are wrapped in a hash:
+
+    Model.to_json(:root=>true)
+    # {"models":[{"model":{"id":1}}]}
+
+    Model.to_json(:root=>:collection)
+    # {"models":[{"id":1}]}
+
+    Model.to_json(:root=>:instance)
+    # [{"model":{"id":1}}]
+
+  Wrapping both the collection and instance in a root by default
+  is probably an undesired behavior, so the default for :root=>true
+  may change in the next major version of Sequel.  Users who want
+  the current behavior should switch to using :root=>:both.
+
+* The schema_dumper extension now respects an :index_names option
+  when dumping.  This option can be set to false to never dump the
+  index names.  It can also be set to :namespace, in which case if
+  the database does not have a global index namespace, it will
+  automatically prefix the name of the index with the name of the
+  table.
+
+  Database#global_index_namespace? was added to check if the
+  database uses a global index namespace.  If false, index names are
+  probably namespaced per table (MySQL, MSSQL, Oracle).
+
+* :each is now a valid prepared statement type.  This prepared
+  statement type requires a block when you call the statement, and
+  iterates over the records of the statement a row at a time.
+  Previously, there wasn't a way to iterate over the records of a
+  prepared statement a row at a time, since the :select and :all
+  types collect all rows into an array before iterating over them.
+
+* A :connection_handling=>:queue option is now respected for
+  database objects, and changes the threaded connection pools to use
+  a queue instead of a stack as the data structure for storing
+  available connections.  A queue does not perform as well as a
+  stack, but reduces the likelihood of stale connections.
+
+  It is possible that Sequel will change in the future from using a
+  stack by default to using a queue by default, so any users who
+  specifically desire a stack to be used should specify the
+  :connection_handling=>:stack option.
+
+* Sequel::Migrator now supports is_current? class method to check
+  if there are no outstanding migrations to apply.  It also supports
+  a check_current class method, which raises an exception if there
+  are outstanding migrations to apply.
+
+* A pg_json extension has been added, supporting PostgreSQL's 9.2
+  json type, similarly to the pg_array and pg_hstore extensions.
+  Note that with the current PostgreSQL json code, the root object
+  can be a string or number, but ruby's json library requires the
+  root json value to be an object or array.  So you will probably
+  get an exception if you attempt to retrieve a PostgreSQL json
+  value that ruby's JSON library won't parse.
+
+* A pg_inet extension has been added, which automatically typecasts
+  PostgreSQL inet and cidr types to ruby IPAddr objects on retrieval.
+
+* Database#transaction on PostgreSQL now recognizes :read_only and
+  :deferrable options, and can use them to set the READ ONLY and
+  DEFERRABLE transaction flags.  A :synchronous option is also
+  recognized, which can be set to true, false, :local, or
+  :remote_write, and sets the value of synchronous_commit just for
+  that transaction.
+
+* When adding and dropping indexes on PostgreSQL, a :concurrently
+  option can be used to create or drop the index CONCURRENTLY, which
+  doesn't require a full write table lock.
+
+* When dropping indexes on PostgreSQL, :if_exists and :cascade options
+  are now recognized.
+
+* When using alter_table set_column_type on PostgreSQL, the :using
+  option is respected, and can be used to force a specific conversion
+  from the previous value to the new value with the USING syntax.
+
+* On MySQL, you can now set an :sql_mode option when connecting.  This
+  can be a string or symbol or an array of them, and each should match
+  one of MySQL's sql_modes.  MySQL's default SQL mode is fairly loose,
+  and using one of the strict sql modes is recommended, but for
+  backwards compatibility, Sequel will not set a specific SQL mode by
+  default.  However, that may change in the next major version of
+  Sequel, so to be forwards compatible you should set :sql_mode=>nil
+  if you do not desire a strict SQL mode to be set automatically.
+
+* Partial indexes are now supported on Microsoft SQL Server 2008
+  (SQL Server refers to them as filtered indexes).  Attempting to
+  use a partial index on an earlier version of SQL Server will
+  result in the database raising an exception.
+
+* A jdbc/progress adapter has been added, supporting the Progress
+  database via the jdbc adapter.
+
+= Other Improvements
+
+* Dataset#get now works correctly if you pass it a nil or false
+  argument.  Previously, it ignored the argument and used the block
+  instead.  If you want to use the block argument, you should not
+  pass in a regular argument.
+
+* Database#call now passes any blocks given to it to the underlying
+  prepared statement object.  Before, a passed block was ignored.
+
+* Sequel::Model.db is no longer set automatically when creating
+  an anonymous class with an associated database object.  This fixes
+  cases where a library would create namespaced models, and the
+  database used by the library would be set as the default for the
+  user's application code.
+
+* Model *_to_one association setters are now no-ops if you pass a
+  value that is the same as the cached value.  This fixes issues with
+  reciprocal associations getting reordered, and is better
+  for performance.
+
+  For cases where the old behavior is desired, the
+  set_associated_object_if_same? method can be overridden to return
+  true for object.  If you are manually setting objects in the
+  associations cache before calling the setter method, you may want
+  to set that.
+
+* The dirty plugin no longer affects the return value of refresh
+  and lock!.  Internal changes should now help ensure that plugins
+  don't affect the return values of these methods.
+
+* Sequel now supports JRuby 1.7's new exception handling, fixing
+  exception handling when connecting in the jdbc adapter.
+
+* When dumping unsigned integer types in the schema dumper, if the
+  unsigned values could overflow a 32-bit signed integer type,
+  the generic Bignum class is used as the type.  This should fix
+  issues when copying a database containing an unsigned 32-bit
+  integer column with values between 2^31 and 2^32-1.
+
+* In the optimistic_locking plugin, attempting to refresh and
+  save after a failed save now works correctly.  Before, the second
+  save would never modify a row.
+
+* Time types on jdbc/postgres are now typecasted accurately on
+  retrieval, before they could be off by up to a millisecond due to
+  floating point issues.
+
+* Disconnect detection in the mysql2 adapter has been improved.
+
+* The jdbc/mysql, do/mysql, and swift/mysql adapters all now support
+  the :timeout option to set the MySQL wait_timeout.
+
+* Savepoints in prepared transactions are now supported on MySQL
+  5.5.23+, since the bug that caused them to be unsupported starting
+  in 5.5.13 has been fixed.
+
+* Parsing foreign key metadata for tables with an explicit
+  schema now works correctly on PostgreSQL.
+
+* bin/sequel -C now namespaces indexes automatically when copying
+  from a database without a global index namespace to a database
+  with a global index namespace.
+
+* Indexes are now dropped in reverse order that they were added in
+  the schema_dumper.
+
+* The Model typecasting code works around bugs in objects where
+  object.==('') would raise an exception instead of returning false.
+
+* A better error message is used if an invalid JDBC URL is
+  provided and the JDBC driver's new.connect method returns NULL.
+
+* A document describing Sequel's object model has been added,
+  describing the objects Sequel uses to represent SQL concepts.
+
+* Most adapter specific options to Database methods are now mentioned
+  in the main Database method RDoc.
+
+= Backwards Compatibility
+
+* The nested_attributes plugin internals changed significantly.  If
+  you were overriding one of the nested_attributes* private methods
+  and calling super to get the default behavior, you may have to
+  update your code.
+
+* Database#case_sensitive_like has been removed on SQLite.  This
+  method never worked correctly, it always returned false even if
+  the case_sensitive_like PRAGMA was set.  That's because SQLite
+  doesn't offer a getter for this PRAGMA, only a setter.  Note that
+  Database#case_sensitive_like= still exists and works correctly.
+
+* Database#single_value has been removed from the native SQLite
+  adapter.  This method was designed for internal use, and hasn't
+  been used for some time.  Any current users of the method should
+  switch to Dataset#single_value.
+
+* The private Database#defined_columns_for method in the SQLite
+  adapter no longer takes an options hash.
+
+* A couple jdbc/postgres adapter methods are now private.  Previously,
+  the jdbc/postgres adapter overrode some private superclass methods
+  but left the methods public.
+
+* When using the optimistic_locking plugin, refreshing inside a
+  before_update method after calling super will now result in the
+  lock checking being skipped.
+
+* The private Model#_refresh no longer returns self, so external
+  plugins should no longer rely on that behavior.

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/release_notes/3.37.0.txt

@@ -0,0 +1,338 @@
+= 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
+      ...
+      exclude([[: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.
+