asana2flowdock 1.0.0

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

@@ -0,0 +1,202 @@
+= New Features
+
+* Prepared statements now support :map and :to_hash prepared
+  statement types.  The main reason for this is that certain
+  extensions (e.g. sequel_pg) optimize map/to_hash calls, and
+  there previously was not a way to use prepared statements
+  with the map/to_hash optimizations.
+
+* Sequel.empty_array_handle_nulls has been added to change how
+  IN/NOT IN operations with an empty array are handled.  See
+  the Backwards Compatibility section for details.
+
+* 5 new association options have been added that allow you to
+  define associations where the underlying columns clash with
+  standard ruby method names:
+
+    many_to_one :primary_key_method
+    one_to_many :key_method
+    one_to_many :primary_key_column
+    many_to_many :left_primary_key_column
+    many_to_many :right_primary_key_method
+
+  Using these new options, you can now define associations
+  that work correctly when the underlying primary/foreign key
+  columns clash with existing ruby method names.  See the RDoc
+  for details.
+
+* A use_after_commit_rollback setting has been added to models.
+  This defaults to true, but can be set to false for performance
+  or to allow models to be used in prepared transactions
+  (which don't support after_commit/after_rollback).
+
+* Dataset#update_ignore has been added when connecting to MySQL,
+  enabling use of the UPDATE IGNORE syntax to skip updating a row
+  if the update would cause a unique constraint to be violated.
+
+* Database#indexes is now supported when connecting to Microsoft
+  SQL Server.
+
+* On Microsoft SQL Server, the :include option is now supported
+  when creating indexes, for storing column values in the index,
+  which can be used by the query optimizer.
+
+= Other Improvements
+
+* The filtering/excluding by associations code now uses qualified
+  identifiers instead of unqualified identifiers, which allows it
+  to avoid ambiguous column names if you are doing your own joins.
+
+* Virtual row blocks that return arrays are now handled correctly
+  in Dataset#select_map/select_order_map.
+
+* Dataset#select_map/select_order_map can now take both a block
+  argument as well as a regular argument.
+
+* Dataset#select_order_map now handles virtual row blocks that
+  return ordered expressions.
+
+* Database#table_exists? should no longer generate false negatives
+  if you only have permission to retrieve some column values but
+  not all.  Note that if you lack permission to SELECT from the
+  table itself, table_exists? can still generate false negatives.
+
+* The active_model plugin now supports ActiveModel 3.2, by adding
+  support for to_partial_path.
+
+* The serialization_modification_detection plugin now handles
+  changed_columns correctly both for new objects and after saving
+  objects.
+
+* The serialization plugin now clears the deserialized values when
+  it does the automatic refresh after saving a new object, mostly for
+  consistency.  You can use the skip_create_refresh plugin to skip
+  refreshing when creating a new model object.
+
+* Column default values are now wrapped in parentheses on SQLite,
+  which fixes some cases such as when the default is an SQL function
+  call.
+
+* Alter table emulation now works correctly on SQLite when foreign
+  keys reference the table being altered.  The emulation requires
+  a renaming/deleting the existing table and creating a new table,
+  which can break foreign key references.  Sequel now disables the
+  foreign key PRAGMA when altering tables, so SQLite won't track
+  the table renames and break the foreign key relationships.
+
+* The set_column_type table alteration method no longer modifies
+  default values and NULL/NOT NULL settings on Microsoft SQL
+  Server, H2, and SQLite.
+
+* On MySQL, Time/DateTime columns now use the timestamp type if the
+  default value is Sequel::CURRENT_TIMESTAMP, since it is currently
+  impossible for MySQL to have a non-constant default for a
+  datetime column (without using a workaround like a trigger).
+
+* Metadata methods such as tables, views, and view_exists? are now
+  handled correctly on Oracle if custom identifier input methods
+  are used.
+
+* Sequel now ignores errors that occur when attempting to get
+  information on column defaults in Oracle (which can happen if you
+  lack permission to the appropriate table).  Previously, such errors
+  would cause the schema parser to raise an error, now, the schema
+  information is just returned without default information.
+
+* Database#indexes now skips the primary key index when connecting to
+  DB2, Derby, HSQLDB, and Oracle via the jdbc adapter.
+
+* Database#indexes now works correctly on DB2.
+
+* The progress adapter has been fixed, it had been broken since the
+  dataset literalization refactoring.
+
+* Dataset#naked! now works correctly.  Previously, it just returned
+  the receiver unmodified.
+
+* Dataset#paginate! has been removed, as it was broken.
+
+* The query extension no longer breaks Dataset#clone if an argument
+  is not given.
+
+* Transaction related queries are no longer logged twice in the mock
+  adapter.
+
+= Backwards Compatibility
+
+* Sequel's default handling of NOT IN operators with an empty array
+  of values has changed, which can change which rows are returned for
+  such queries.
+ 
+  Previously, Sequel was inconsistent in that it tried to handle NULL
+  values correctly in the IN case, but not in the NOT IN case.  Now,
+  it defaults to handling NULL values correctly in both cases:
+
+    # 3.31.0
+    DB[:a].where(:b=>[])
+    # SELECT * FROM a WHERE (b != b)
+    DB[:a].exclude(:b=>[])
+    # SELECT * FROM a WHERE (1 = 1)
+
+    # 3.32.0
+    DB[:a].where(:b=>[])
+    # SELECT * FROM a WHERE (b != b)
+    DB[:a].exclude(:b=>[])
+    # SELECT * FROM a WHERE (b = b)
+
+  The important change in behavior is that in the NOT IN case, if
+  the left hand argument is NULL, the filter returns NULL instead
+  of true.  This has the potential to change query results.
+
+  "Correct" here is really an opinion and not a fact, as there are
+  valid arguments for the alternative behavior:
+
+    DB[:a].where(:b=>[])
+    # SELECT * FROM a WHERE (1 = 0)
+    DB[:a].exclude(:b=>[])
+    # SELECT * FROM a WHERE (1 = 1)
+
+  The difference is that the "correct" NULL behavior is more
+  consistent with the non-empty array cases.  For example, if b is
+  NULL:
+
+    # "Correct" NULL handling
+    #  Empty array: where(:b=>[])
+    WHERE (b != b) # NULL
+    WHERE (b = b) # NULL
+    #  Non-empty array: where(:b=>[1, 2])
+    WHERE (b IN (1, 2)) # NULL
+    WHERE (b NOT IN (1, 2)) # NULL
+
+    # Static boolean handling
+    #  Empty array: where(:b=>[])
+    WHERE (1 = 0) # false
+    WHERE (1 = 1) # true
+    #  Non-empty array: where(:b=>[1, 2])
+    WHERE (b IN (1, 2)) # NULL
+    WHERE (b NOT IN (1, 2)) # NULL
+
+  Sequel chooses to default to behavior consistent with the non-empty
+  array cases (similar to SQLAlchemy).  However, there are two
+  downsides to this handling.  The first is that some databases with
+  poor optimizers (e.g. MySQL) might do a full table scan with the
+  default syntax.  The second is that the static boolean handling may
+  be generally perferable, if you believe that IN/NOT IN with an
+  empty array should always be true or false and never NULL even if
+  the left hand argument is NULL.
+
+  As there really isn't a truly correct answer in this case, Sequel
+  defaults to the "correct" NULL handling, and allows you to switch
+  to the static boolean handling via:
+
+    Sequel.empty_array_handle_nulls = false
+
+  This is currently a global setting, it may be made Database or
+  Dataset specific later if requested.  Also, it is possible the
+  default will switch in the future, so if you care about a specific
+  handling, you should set your own default.
+
+* Database#table_exists? now only rescues Sequel::DatabaseErrors
+  instead of StandardErrors, so it's possible it will raise errors
+  instead of returning false on custom adapters that don't wrap
+  their errors correctly.

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

@@ -0,0 +1,157 @@
+= New Features
+
+* A server_block extension has been added that makes Sequel's
+  sharding support easier to use by scoping database access inside
+  the block to a given server/shard:
+
+    Sequel.extension :server_block
+    DB.extend Sequel::ServerBlock
+    DB.with_server(:shard_1) do
+      # All of these will execute against shard_1
+      DB.tables
+      DB[:table].all
+      DB.run 'SOME SQL'
+    end
+
+* An arbitrary_servers extension has been added that extends
+  Sequel's sharding support so that you can use arbitrary
+  connection options instead of referencing an existing, predefined
+  server/shard:
+
+    Sequel.extension :arbitrary_servers
+    DB.pool.extend Sequel::ArbitraryServers
+    DB[:table].server(:host=>'foo', :database=>'bar').all
+
+  You can use this extension in conjunction with the server_block
+  extension:
+
+    DB.with_server(:host=>'foo', :database=>'bar') do
+      DB.synchronize do
+        # All of these will execute on host foo, database bar
+        DB.tables
+        DB[:table].all
+        DB.run 'SOME SQL'
+      end
+    end
+
+  The combination of these two extensions makes it pretty easy to
+  write a thread-safe Rack middleware that scopes each request
+  to an arbitrary database.
+
+* The sqlite adapter now supports an integer_booleans setting
+  for using 1/0 for true/false values, instead of the the 't'/'f'
+  values used by default.  As SQLite recommends using integers to
+  store booleans, converting your existing database and enabling
+  this setting is recommended, but for backwards compatibility it
+  is set to false.  You can convert you existing database by doing
+  the following for each table/column that has booleans:
+
+    DB[:table].update(:boolean_column=>{'t'=>1}.
+                        case(0, :boolean_column))
+
+  The integer_booleans default setting may change in a future
+  version of Sequel, so you should set it manually to false if you
+  prefer the current default.
+
+* You can now disable transaction use in migrations, in one of two
+  ways.  You generally only need to do this if you are using an
+  SQL query inside a migration that is specifically not supported
+  inside a transaction, such as CREATE INDEX CONCURRENTLY on
+  PostgreSQL.
+  
+  The first way to disable transactions is on a per-migration basis
+  by calling the no_transaction method inside the Sequel.migration
+  block:
+
+    Sequel.migration do
+      no_transaction
+      change do
+        # ...
+      end
+    end
+
+  That will make it so that a transaction is not used for that
+  particular migration.  The second way is passing the
+  :use_tranctions=>false option when calling Migrator.run (using
+  the API), which will completely disable transactions for all
+  migrations during the migrator run.
+
+* The postgres adapter now respects an :sslmode option when using
+  pg as the underlying driver, you can set the value of this option to
+  disable, allow, prefer, or require.
+
+* Database#create_schema and #drop_schema are now defined when
+  connecting to PostgreSQL.
+
+* Database#supports_savepoints_in_prepared_transactions? has been
+  added for checking if savepoints are supported inside prepared
+  transactions.  This is true if both savepoints and prepared
+  transactions are both supported, except on MySQL > 5.5.12 (due to
+  MySQL bug 64374).
+
+= Other Improvements
+
+* The mysql and mysql2 adapters now both provide an accurate number
+  of rows matched, so Sequel::Model usage on those adapters will now
+  raise a NoExistingObject exception by default if you attempt to
+  delete or update an instance that no longer exists in the database.
+
+* Foreign key creation now works correctly without specifying the
+  :key option when using MySQL with the InnoDB table engine.  InnoDB
+  requires that you list the column explicitly, even if you are
+  referencing the primary key of the table, so if the :key option is
+  not given, the database schema is introspected to find the primary
+  key for the table.  If you are attempting to create a table with
+  a self-referential foreign key, it introspects the generator to
+  get the primary key for the table.
+
+* The sqlite adapter will now return 1/0 stored in boolean columns as
+  true/false.  It will convert dates stored as Integers/Floats to
+  Date objects by assuming they represent the julian date.  It will
+  convert times stored as Integers/Floats to Sequel::SQLTime objects
+  by assuming they represent a number of seconds. It will convert
+  datetimes stored as Integers by assuming they represent a unix
+  epoch time integer, and datetimes stored as Floats by assuming the
+  represent the julian date (with fractional part representing the
+  time of day).  These changes make Sequel handle SQLite's
+  recommendations for boolean/date/time storage.
+
+* The instance_hooks plugin's (before|after)_*_hook methods now return
+  self so they can be used in a method chain.
+
+* The list plugin now automatically adds new entries to the end of the
+  list when creating the entries, if the position field is not
+  specifically set.
+
+* An identifier_output_method is now respected in the mysql2 adapter.
+
+* NaN/Infinity Float values are now quoted correctly for input on
+  PostgreSQL, and the postgres adapter correctly handles them on
+  retrieval from the database.
+
+* The :collate column option is now respected when creating tables or
+  altering columns on MySQL.
+
+* You can now force use of the TimestampMigrator when the
+  IntegerMigrator would be used by default by calling
+  TimestampMigrator.apply or .run.
+
+* Mock adapter usage with a specific SQL dialect now uses the
+  appropriate defaults for quoting identifiers.
+
+* You can now disable the use of sudo in the rake install/uninstall
+  tasks using the SUDO='' environment variable.
+
+* A very misleading error message has been fixed when attempting
+  to constantize an invalid string in the model inflector.
+
+= Backwards Compatibility
+
+* The sqlite adapter now typecasts columns that SQLite stores as
+  INTEGER/REAL.  Previously, it only typecasted columns that
+  SQLite stored as TEXT/BLOB.  For details about SQLite storage, see
+  http://www.sqlite.org/datatype3.html.
+
+  Any custom type conversion procs used with the sqlite adapter should
+  be modified to work with Integer/Float objects in addition to String
+  objects.

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

@@ -0,0 +1,671 @@
+= New PostgreSQL Extensions
+
+* A pg_array extension has been added, supporting PostgreSQL's
+  numeric and string array types.  Both single dimensional and
+  multi-dimensional array types are supported.  Array values are
+  returned as instances of Sequel::Postgres::PGArray, which is a
+  delegate class of Array.  You can turn an existing array into
+  a PGArray using Array#pg_array.
+
+  If you are using arrays in model objects, you need to load
+  support for that:
+
+    DB.extend Sequel::Postgres::PGArray::DatabaseMethods
+
+  This makes schema parsing and typecasting of array columns work
+  correctly.
+
+  This extension also allows you to use PGArray objects and arrays
+  in bound variables when using the postgres adapter with pg.
+
+* A pg_hstore extension has been added, supporting PostgreSQL's hstore
+  type, which is a simple hash with string keys and string or NULL
+  values.  hstore values are retrieved as instances of
+  Sequel::Postgres::HStore, which is a delegate class of Hash.  You
+  can turn an existing hash into an hstore using Hash#hstore.
+
+  If you are using hstores in model objects, you need to load
+  support for that:
+
+    DB.extend Sequel::Postgres::HStore::DatabaseMethods
+
+  This makes schema parsing and typecasting of hstore columns work
+  correctly.
+
+  This extension also allows you to use HStore objects and hashes
+  in bound variables when using the postgres adapter with pg.
+
+* A pg_array_ops extension has been added, making it easier to call
+  PostgreSQL array operators and functions using plain ruby code.
+  Examples:
+
+    a = :array_column.pg_array
+    a[1]              # array_column[1]
+    a[1][2]           # array_column[1][2]
+    a.push(1)         # array_column || 1
+    a.unshift(1)      # 1 || array_column
+    a.any             # ANY(array_column)
+    a.join            # array_to_string(array_column, '', NULL)
+
+  If you are also using the pg_array extension, you can turn
+  a PGArray object into a query object, which allows you to run
+  operations on array literals:
+
+    a = [1, 2].pg_array.op
+    a.push(3)               # ARRAY[1,2] || 3
+
+* A pg_hstore_ops extension has been added, making it easier to call
+  PostgreSQL hstore operators and functions using plain ruby code.
+  Examples:
+
+    h = :hstore_column.hstore
+    h['a']             # hstore_column -> 'a'
+    h.has_key?('a')    # hstore_column ? 'a'
+    h.keys             # akeys(hstore_column)
+    h.to_array         # hstore_to_array(hstore_column)
+
+  If you are also using the pg_hstore extension, you can turn
+  an HStore object into a query object, which allows you to run
+  operations on hstore literals:
+
+    h = {'a' => 'b'}.hstore.op
+    h[a]               # '"a"=>"b"'::hstore -> 'a'
+
+* A pg_auto_parameterize extension has been added for automatically
+  using bound variables for all queries.  For example, it can take
+  code such as:
+
+    DB[:table].where(:column=>1)
+  
+  and do:
+
+    SELECT * FROM table WHERE column = $1; -- [1]
+
+  Note that automatically parameterizing queries is not generally
+  faster unless the bound variables are large (i.e. long text/bytea
+  values).  Also, there are multiple corner cases when automatically
+  parameterizing queries, though most can be worked around by
+  adding explicit casts.
+
+* A pg_statement_cache extension has been added that works with the
+  pg_auto_parameterize extension for automatically caching prepared
+  statements and reusing them when using the postgres adapter with
+  pg.  The combination of these two extensions makes it possible to
+  take an entire Sequel application and turn most or all of the
+  queries into prepared statements.
+
+  Note that these two extensions do not necessarily improve
+  performance.  For simple queries, they actually hurt performance.
+  They do help for complex queries, but in all cases, it's faster
+  to use Sequel's prepared statements API manually.
+
+= Other New Extensions
+
+* A query_literals extension has been added that makes the select,
+  group, and order methods operate similar to the filter methods in
+  that if they are given a regular string as their first argument,
+  they treat it as a literal string, with additional arguments, if
+  any, used as placeholder values.  This extension allows you to
+  write code such as:
+
+    DB[:table].select('a, b, ?' 2).group('a, b').order('c')
+    # Without query_literals:
+    #   SELECT 'a, b, ?', 2 FROM table GROUP BY 'a, b' ORDER BY 'c'
+    # With query_literals:
+    #   SELECT a, b, 2 FROM table GROUP BY a, b ORDER BY c
+
+  Sequel's default handling in this case is to use literal strings,
+  which is generally not desired and on some databases not even
+  valid syntax.  In general, you'll probably want to use this
+  extension for all of a database's datasets, which you can do via:
+
+    Sequel.extension :query_literals
+    DB.extend_datasets(Sequel::QueryLiterals)
+
+  The next major version of Sequel (4.0.0) will probably integrate
+  this extension into the core library.
+
+* A select_remove extension has been added that adds
+  Dataset#select_remove, for removing selected columns/expressions
+  from a dataset:
+
+    ds = DB[:table]
+    # Assume table has columns a, b, and c
+
+    ds.select_remove(:c)
+    # SELECT a, b FROM table
+
+    # Removal by column alias
+    ds.select(:a, :b___c, :c___b).select_remove(:c)
+    # SELECT a, c AS b FROM table 
+    
+    # Removal by expression
+    ds.select(:a, :b___c, :c___b).select_remove(:c___b)
+    # SELECT a, b AS c FROM table 
+    
+  This method makes it easier to select all columns except for the
+  columns given.  This is common in cases where a table has a few
+  large columns that are expensive to retrieve.  This method does
+  have some corner cases, so read the documentation before using it.
+
+* A schema_caching extension has added that makes it possible for
+  Database instances to dump the cached schema metadata to a
+  marshalled file, and load the cached schema metadata from the file.
+  This can be significantly faster than reparsing the schema from the
+  database, especially for databases with high latency.
+
+  bin/sequel -S has been added to dump the schema for the given
+  database to a file, and DB.load_schema_cache(filename) can be used
+  to populate the schema cache inside your application.  This should
+  be done after creating the Database object but before loading your
+  model files.
+
+  Note that Sequel does no checking to ensure that the cached schema
+  currently reflects the state of the database.  That is up to the
+  application.
+
+* A null_dataset extension has been added, which adds
+  Dataset#nullify for creating a dataset that will not issue a
+  database query.  It implements the null object pattern for
+  datasets, and is probably most useful in methods that must return
+  a dataset, but can determine that such a dataset will never return
+  a row.
+
+= New Plugins
+
+* A static_cache plugin has been added, allowing you to cache a model
+  statically.  This plugin is useful for models whose tables do not
+  change while the application is running, such as lookup tables.
+  When using this plugin, the following methods will no longer require
+  queries:
+
+  * Primary key lookups (e.g. Model[1])
+  * Model.all calls
+  * Model.each calls
+  * Model.map calls without an argument
+  * Model.to_hash calls without an argument
+
+  The statically cached model instances are frozen so they are not
+  accidently modified.
+
+* A many_to_one_pk_lookup plugin has been added that changes the
+  many_to_one association retrieval code to do a simple primary
+  key lookup on the associated class in most cases.  This results
+  in significantly better performance, especially if the
+  associated model is using a caching plugin (either caching
+  or static_cache).
+
+= Core Extension Replacements
+
+* Most of Sequel's core extensions now have equivalent methods defined
+  on the Sequel module:
+
+    :column.as(:alias)        -> Sequel.as(:column, :alias)   
+    :column.asc               -> Sequel.asc(:column)
+    :column.desc              -> Sequel.desc(:column)
+    :column.cast(Integer)     -> Sequel.cast(:column, Integer)
+    :column.cast_numeric      -> Sequel.cast_numeric(:column)
+    :column.cast_string       -> Sequel.cast_string(:column)
+    :column.extract(:year)    -> Sequel.extract(:year, :column)
+    :column.identifier        -> Sequel.identifier(:column)
+    :column.ilike('A%')       -> Sequel.ilike(:column, 'A%')
+    :column.like('A%')        -> Sequel.like(:column, 'A%')
+    :column.qualify(:table)   -> Sequel.qualify(:table, :column)
+    :column.sql_subscript(1)  -> Sequel.subscript(:column, 1)
+    :function.sql_function(1) -> Sequel.function(:function, 1)
+    'some SQL'.lit            -> Sequel.lit('some SQL')
+    'string'.to_sequel_blob   -> Sequel.blob('string')
+    {:a=>1}.case(0)           -> Sequel.case({:a=>1}, 0)
+    {:a=>1}.sql_negate        -> Sequel.negate(:a=>1)
+    {:a=>1}.sql_or            -> Sequel.or(:a=>1)
+    [[1, 2]].sql_value_list   -> Sequel.value_list([[1, 2]])
+    [:a, :b].sql_string_join  -> Sequel.join([:a, :b])
+    ~{:a=>1}                  -> Sequel.~(:a=>1)
+    :a + 1                    -> Sequel.+(:a, 1)
+    :a - 1                    -> Sequel.-(:a, 1)
+    :a * 1                    -> Sequel.*(:a, 1)
+    :a / 1                    -> Sequel./(:a, 1)
+    :a & 1                    -> Sequel.&(:a, 1)
+    :a | 1                    -> Sequel.|(:a, 1)
+
+* You can now wrap any object in a Sequel expression using
+  Sequel.expr.  This is similar to the sql_expr extension, but
+  without defining the sql_expr method on all objects:
+
+    1.sql_expr                -> Sequel.expr(1)
+
+  The sql_expr extension now just has Object#sql_expr call
+  Sequel.expr.
+
+* Virtual Rows now have methods defined that handle the standard
+  mathematical operators:
+
+    select{|o| o.+(1, :a)} # SELECT (1 + a)
+
+  the standard inequality operators:
+
+    where{|o| o.>(2, :a)}  # WHERE (2 > a)
+
+  and the standard boolean operators:
+
+    where{|o| o.&({:a=>1}, o.~(:b=>1))} # WHERE ((a = 1) AND (b != 1))
+
+  Additionally, there is now direct support for creating literal
+  strings in instance_evaled virtual row blocks using `:
+
+    where{a > `some crazy SQL`} # WHERE (a > some crazy SQL)
+
+  This doesn't override Kernel.`, since virtual rows use a BasicObject
+  subclass.  Previously, using ` would result in calling the SQL
+  function named ` with the given string, which probably isn't valid
+  syntax on most databases.
+
+* You can now require 'sequel/no_core_ext' to load Sequel without the
+  core extensions.  The previous way of setting the
+  SEQUEL_NO_CORE_EXTENSIONS constant or environment variable before
+  loading Sequel still works.
+
+* The core extensions have been moved from Sequel's core library into
+  an extension that is loadable with Sequel.extension.  This extension
+  is still loaded by default for backwards compatibility.  However,
+  the next major version of Sequel will no longer load this extension
+  by default (though it will still be available to load manually).
+
+* You can now check if the core extensions have been loaded by using
+  Sequel.core_extensions?.
+
+= Foreign Keys in the Schema Dumper
+
+* Database#foreign_key_list has been added that gives an array of
+  foreign key constraints on the table.  It is currently implemented
+  on MySQL, PostgreSQL, and SQLite, and may be implemented on other
+  database types in the future.  Each entry in the return array is
+  a hash, with at least the following keys present:
+
+  :columns :: An array of columns in the given table
+  :table :: The table referenced by the columns
+  :key :: An array of columns referenced (in the table specified by
+          :table), but can be nil on certain adapters if the primary
+          key is referenced.
+
+  The hash may also contain entries for:
+
+  :deferrable :: Whether the constraint is deferrable
+  :name :: The name of the constraint
+  :on_delete :: The action to take ON DELETE
+  :on_update :: The action to take ON UPDATE
+
+* The schema_dumper extension now dumps foreign key constraints on
+  databases that support Database#foreign_key_list.  On such
+  databases, dumping a schema migration will dump the tables in
+  topological order, such that referenced tables always come before
+  referencing tables.
+
+  In case there is a circular dependency, Sequel breaks the
+  dependency and adds separate foreign key constraints at the end
+  of the migration.  However, when a circular dependency is broken,
+  the migration can probably not be migrated down.
+
+  Foreign key constraints can also be dumped as a separate migration
+  using Database#dump_foreign_key_migration, similar to how
+  Database#dump_indexes_migration works.
+
+* When using bin/sequel -C to copy databases, foreign key constraints
+  are now copied if the source database supports
+  Database#foreign_key_list.
+
+= Other New Features
+
+* Dataset#to_hash_groups and #select_hash_groups have been added.
+  These methods are similar to #to_hash and #select_hash in that they
+  return a hash, but hashes returned by *_hash_groups methods have
+  arrays of all matching values, unlike the *_hash methods which
+  just use the last matching value. Example:
+
+    DB[:table].all
+    # => [{:a=>1, :b=>2}, {:a=>1, :b=>3}, {:a=>2, :b=>4}]
+
+    DB[:table].to_hash(:a, :b)
+    # => {1=>3, 2=>4}
+
+    DB[:table].to_hash_groups(:a, :b)
+    # => {1=>[2, 3], 2=>[4]}
+
+* Model#set_fields and #update_fields now accept :missing=>:skip and
+  :missing=>:raise options, allowing them to be used in more cases.
+  :missing=>:skip skips missing entries in the hash, instead of
+  setting the field to the default hash value.  :missing=>:raise
+  raises an error for missing fields, similar to
+  strict_param_setting = true.  It's recommended that these options
+  be used in new code in preference to #set_only and #update_only.
+
+* Database#drop_table? has been added, for dropping tables if they
+  already exist.  This uses DROP TABLE IF EXISTS on the databases that
+  support it.  Database#supports_drop_table_if_exists? has been added
+  for checking whether the database supports that syntax.
+
+* Database#create_join_table has been added that allows easy 
+  creation of many_to_many join tables:
+
+    DB.create_join_table(:album_id=>:albums, :artist_id=>:artists)
+
+  This uses real foreign keys for both of the columns, uses a
+  composite primary key of both of the columns, and adds an
+  additional composite index of the columns in reverse order.  The
+  primary key and additional index should ensure that almost all
+  operations on the join table can benefit from an index.
+
+  In terms of customization, the values in the hash can be hashes
+  themselves for column specific options, and an additional options
+  hash can also be given to override some of the default settings.
+
+  Database#drop_join_table also exists and takes the same options
+  as create_join_table.  It mostly exists to make it easy to
+  reverse migrations that use create_join_table.
+
+* Model#freeze has been added that freezes a model such that it
+  works correctly in a read-only state.  Before, it used the standard
+  Object#freeze, which broke some things that should work, and
+  allowed changes that shouldn't be allowed (like modifying the
+  instance's values).
+
+* ConnectionPool#all_connections has been added, which yields each
+  available connection in the pool to the block.  For threaded pools,
+  it does not yield connections that are currently being used by
+  other threads.  When using this method, it is important to only
+  operate on the yielded connection objects, and not make any
+  modifications to the pool itself.  The pool is also locked until
+  the method returns.
+
+* ConnectionPool#after_connect= has been added, allowing you to
+  change a connection pool's after_connect proc after instantiating
+  the pool.
+
+* ConnectionPool#disconnection_proc= has been added, allowing you to
+  change a connection pool's disconnection_proc after instantiating the
+  pool.
+
+* A Model.cache_anonymous_models accessor has been added, and can be
+  set to false to disable the caching of classes created by
+  Sequel::Model().  This caching is only useful if you want to reload
+  the model's file without getting a superclass mismatch.  This
+  setting is true by default for backwards compatibility, but may be
+  changed to false in a later version, so you should manually set it to
+  true if you are using code reloading.
+
+* Model.instance_dataset has been added for getting the dataset used
+  for model instances (a naked dataset restricted to a single row).
+
+* Dataset#with_sql_delete has been added for running the given SQL
+  string as a delete and returning the number of rows modified.  It's
+  designed as a replacement for with_sql(sql).delete, which is slower
+  as it requires cloning the dataset.
+
+* The :on_update and :on_delete entries for foreign_key now accept
+  string arguments which are used literally.
+
+* Prepared statement objects now have a log_sql accessor that can be
+  turned on to log the entire SQL statement instead of just the
+  prepared statement name.
+
+* Dataset#multi_replace has been added on MySQL.  This is similar to
+  multi_insert, but uses REPLACE instead of INSERT.
+
+* Dataset#explain has been added to MySQL.  You can use an
+  :extended=>true option to use EXPLAIN EXTENDED.
+
+* A Database#type_supported? method has been added on PostgreSQL to
+  check if the database supports the given type:
+
+    DB.type_supported?(:hstore)
+
+* Datatabase#reset_conversion_procs has been added to the postgres
+  adapter, for use by extensions that modify the default conversion
+  procs and want to have the database use the updated defaults.
+
+* A Database#convert_infinite_timestamps accessor has been added to
+  the postgres adapter, allowing you to return infinite timestamps as
+  nil, a string, or a float.
+
+* SQL::PlaceholderLiteralString objects can now use a placeholder
+  array, where placeholder values are inserted between array elements.
+  This is about 2.5-3x faster than using a string with ? placeholders,
+  and allows usage of ? inside the array:
+
+    Sequel.lit(["(", " ? ", ")"], 1, 2)  # (1 ? 2)
+
+* SQL::Subscript#[] has been added for accessing members of a
+  multi-dimensional array:
+
+    Sequel.subscript(:column, 1)[2][3]  # column[1][2][3] 
+
+* SQL::Wrapper has been added for wrapping arbitrary objects in a
+  Sequel expression object.
+
+* SQL::QualifiedIdentifier objects can now contain arbitrary Sequel
+  expressions.  Before, they could only contain a few expression
+  types.  This makes it easier to add extensions to support
+  PostgreSQL row-valued types.
+
+= Performance Improvements
+
+* Model.[] when called with a primary key has been made about 110%
+  faster for most models by avoiding cloning datasets.
+
+* Model.[] when called without arguments or with a single nil argument
+  is much faster as it now returns nil immediately instead of issuing
+  a database query.
+
+* Model#delete and Model#destroy have been made about 75% faster for
+  most models by using a static SQL string.
+
+* Model.new is now twice as fast when passed an empty hash.
+
+* Model#set is now four times as fast when passed an empty hash.
+
+* Model#this has been made about 85% faster by reducing the number of
+  dataset clones needed from 3 to 1.
+
+* Some proc activations have been removed, giving minor speedups when
+  running on MRI.
+
+= Other Improvements
+
+* Database#uri and #url now return the connection string given
+  to Sequel.connect.  Previously, they tried to reconstruct the
+  url using the database's options, but that didn't work well in
+  corner cases.
+
+* Database#inspect now shows the URL and/or options given when
+  connecting to the database.  Previously, it showed the URL, or
+  all of the databases options if constructing the URL raised an
+  error.
+
+* Sequel no longer checks for prepared transactions support when
+  using transactions unless a prepared transaction is specifically
+  requested.
+
+* The schema utility dataset cached in the Database object is now
+  reset if you use Database#extend_datasets, ensuring that the new
+  value will use the given extension.
+
+* The prepared_statements* plugins now log the full SQL by default.
+  Since the user doesn't choose the name of the prepared statements,
+  it was often difficult to determine what SQL was actually run if
+  you were only looking at a subsection of the SQL log.
+
+* The nested_attributes plugin's delete/remove support now works
+  correctly when a false value is given for _delete/_remove and
+  strict_param_setting is true.
+
+* The hook_class_methods and validation_class_methods plugins
+  now work correctly when subclassing if the subclass attempts to
+  create instances inside Model.inherited.
+
+* The caching plugin has been refactored.  Model.cache_get_pk and
+  cache_delete_pk have been added for retrieving/deleting from the
+  cache by primary key.  Model.cache_key is now a public method.
+
+* The typecast_on_load plugin now works correctly when saving
+  new model objects when insert_select is supported.
+
+* In the sql_expr extension, nil.sql_expr is no longer treated as
+  a boolean value.  It is now treated as a value with generic type.
+
+* The postgres adapter no longer issues a query to map type names to
+  type oids if no named conversion procs have been registered.
+
+* The postgres adapter now works around issues in ruby-pg by
+  supporting fractional seconds for Time/DateTime values, and
+  supporting SQL::Blob (bytea) values with embedded "\0" characters.
+
+* The postgres adapter now supports pre-defining the PG_NAMED_TYPES
+  and PG_TYPES constants.  This is so extensions can define them,
+  so they don't have to load the postgres adapter file first. If
+  extensions need to use these constants, they should do:
+
+    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
+    PG_TYPES = {} unless defined?(PG_TYPES)
+
+  That way they work whether they are loaded before or after the
+  postgres adapter.
+
+* PostgreSQL 8.2-9.0 now correctly add the RETURNING clause when
+  building queries.  Sequel 3.31.0 added support for returning values
+  from delete/update queries in PostgreSQL 8.2-9.0, but didn't change
+  the literalization code to use the RETURNING clause on those
+  versions.
+
+* The jdbc/postgres adapter now converts Java arrays
+  (Java::OrgPostgresqlJdbc4::Jdbc4Array) to ruby arrays.
+
+* Tables and schemas with embedded ' characters are now handled
+  correctly when parsing primary keys and sequences on PostgreSQL.
+
+* Identifiers are now escaped on MySQL and SQLite. Previously they
+  were quoted, but internal ` characters were not doubled.
+
+* Fractional seconds for the time type are now returned correctly on
+  jdbc (assuming they are returned as java.sql.Time values by JDBC).
+
+* Multiple changes were made to ensure that Sequel works correctly
+  when the core extensions are not loaded.
+
+* Composite foreign key constraints are now retained when emulating
+  alter_table operations on SQLite.  Previously, only single
+  foreign key constraints were retained.
+
+* An error is no longer raised when no indexes exist when calling
+  Database#indexes on jdbc/sqlite.
+
+* A possible SystemStackError has been fixed in the SQLite adapter,
+  when trying to delete a dataset that uses a having clause and no
+  where clause.
+
+* ROLLUP/CUBE support now works correctly on Microsoft SQL Server
+  2005.
+
+* Unsigned tinyint types are now recognized in the schema dumper.
+
+* Using primary_key :column, :type=>Bignum now works correctly on H2.
+  Previously, the column created was not autoincrementing.
+
+* Using a bound variable for a limit is now supported in the ibmdb
+  adapter on ruby 1.9.
+
+* Connecting to PostgreSQL via the swift adapter has been fixed when
+  using newer versions of swift. 
+
+* The mock adapter now handles calling the Database#execute methods
+  directly (instead of via a dataset).
+
+* The mock adapter now has the ability to have per-shared adapter
+  specific initialization code executed.  This has been used to fix
+  some bugs when using the shared postgres adapter.
+
+* The pretty_table extension has been split into two extensions, one
+  that adds a method to Dataset and one that just adds the
+  PrettyTable class.  Also, PrettyTable.string has been added to get
+  a string copy of the table.
+
+* A spec_model_no_assoc task has been added for running model specs
+  without the association plugin loaded.  This is to check that the
+  SEQUEL_NO_ASSOCIATIONS setting works correctly.
+
+= Deprecated Features to be Removed in Sequel 3.35.0
+
+* Ruby <1.8.7 support is now deprecated.
+
+* PostgreSQL <8.2 support is now deprecated.
+
+* Dataset#disable_insert_returning on PostgreSQL is now deprecated.
+  Starting in 3.35.0, RETURNING will now always be used to get the
+  primary key value when inserting.
+
+* Array#all_two_pairs? is now deprecated.  It was part of the core
+  extensions, but the core extensions have been refactored to no
+  longer require it.  As it doesn't specifically relate to creating
+  Sequel expression objects, it is being removed.  The private
+  Array#sql_expr_if_all_two_pairs method is deprecated as well.
+
+= Other Backwards Compatibility Issues
+
+* The generic Bignum type now uses bigint on SQLite, similar to
+  other databases.  The integer type was previously used.  The only
+  exception is for auto incrementing primary keys, which still use
+  integer for Bignum as SQLite doesn't support autoincrementing
+  columns other than integer.
+
+* On SQLite, Dataset#explain now returns a string, similar to
+  PostgreSQL (and now MySQL).
+
+* When using the JDBC adapter, Java::OrgPostgresqlUtil::PGobject
+  objects are converted to ruby strings if the dataset is set to
+  convert types (the default setting).  This is to support the
+  hstore extension, but it could have unforeseen effects if custom
+  types were used.
+
+* For PostgreSQL connection objects, #primary_key and #sequence now
+  require their arguments are provided as already literalized
+  strings.  Note that these methods are being removed in the next
+  version because they will not be needed after PostgreSQL <8.2
+  support is dropped.
+
+* Database#uri and #url now return a string or nil, but never raise
+  an exception.  Previously, they would either return a string
+  or raise an exception.
+
+* The Model @simple_pk and @simple_table instance variables should
+  no longer be modified directly.  Instead, the setter methods should
+  be used.
+
+* Model.primary_key_lookup should no longer be called with a nil
+  value.
+
+* Logging of prepared statements on some adapters has been changed
+  slightly, so log parsers might need to be updated.
+
+* Dataset#identifier_append and #table_ref_append no longer treat
+  literal strings and blobs specially.  Previously, they were treated
+  as identifiers.
+
+* Dataset#qualified_identifier_sql_append now takes 3 arguments, so
+  any extensions that override it should be modified accordingly.
+
+* Some internally used constants and private methods have been
+  deleted:
+
+    Database::CASCADE
+    Database::NO_ACTION
+    Database::SET_DEFAULTS
+    Database::SET_NULL
+    Database::RESTRICT
+    Dataset::COLUMN_ALL
+
+  or moved:
+
+    MySQL::Dataset::AFFECTED_ROWS_RE -> MySQL::Database
+    MySQL::Dataset#affected_rows -> MySQL::Database
+
+* The sql_expr extension no longer creates the
+  Sequel::SQL::GenericComplexExpression class.