RubyGems - asana2flowdock - Versions diffs - 1.0.0 → 1.1.0 - Mend

asana2flowdock 1.0.0 → 1.1.0

Files changed (1595) hide show

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

@@ -1,202 +0,0 @@
-= 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 DELETED Viewed

@@ -1,157 +0,0 @@
-= 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 DELETED Viewed

@@ -1,671 +0,0 @@
-= 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.