Support rolling back transactions in killed threads in Ruby 2.0+.
Delete one version of commit_or_rollback_transaction, since the other works for either case.
Update changelog for last commit
Syntax error in closing tag
List :name as option for DB.add_index
Pass opts[:schema] through to jdbc getTables method
Minor tweak for jdbc Database#tables commit, and update CHANGELOG

:schema should be allowed to be specified as a symbol, as it is
on other adapters.
Make SQLTime#to_s return a string in HH:MM:SS format, since it shouldn't include date information
Add example for a `rake db:migrate` task.
Merge branch 'rake-migrate-docs' of git://github.com/avdi/sequel
Add spec for one_to_one :validate option usage in setter
Support :raise_on_save_failure option for one_to_many associations

Previously, the add/remove association methods for one_to_many
associations explicitly raised exceptions even if the save method
returned false (because the associated object used
raise_on_save_failure = false).  One reason for that is that the
add/remove methods unconditionally added the object to the cached
association and ran callbacks, since the internal _add/_remove
method return values were not inspected.

Change the add/remove methods to return if the _add/_remove methods
return nil/false and :raise_on_save_failure is false.
Support :raise_on_save_failure option for pg_array_to_many and many_to_pg_array associations
Remove mention of after_initialize from instance_hooks

It's no longer a default hook, so there is no reason to reference it.
Don't clear validation instance_hooks until after a successful save

The problem with the previous simpler code is that it cleared them
after validation, even if the object was invalid, meaning that if
you attempted to save it again, it would skip the validation instance
hooks.
Add SQL::Function#over for easier creation of window functions

I think this is a much friendly API than the current virtual row
based usage with :over.
Add SQL::Function#distinct for easier creation of aggregate functions using DISTINCT

This should also be easier than the current :distinct option in
virtual row blocks.
Add #function to SQL::Identifier and SQL::QualifiedIdentifier, allowing for easy use of schema qualified functions or functions names that need quoting

For historical reasons, Sequel has not split symbols in function
names, and for backwards compatibility it can't.  Previously you
couldn't use SQL::Identifier or SQL::QualifiedIdentifier as
function names, so this is a backwards compatible way to support
schema qualified functions.  Previous schema qualified functions
required:

  Sequel.function('schema.function', ...)

Sequel has never quoted function names, which means function names
that required quoting required manual quoting:

  Sequel.function('"function name"', ...)

These new methods integrate nicely with Sequel's virtual row blocks
and Sequel.expr:

  DB.get{schema__function.function(...)}
  Sequel.expr(:"function name").function(...)
Make #* method without arguments on SQL::Function return a Function with * prepended to the arguments

This is the last piece to replace the empty blocks used in virtual row
block method calls.  Previously, there were four things the empty blocks
did, and now they all have simple replacements:

* func{} => func.function
* func(:*){} => func.function.*
* func(:distinct, 1){} => func(1).distinct
* func(:over, :args=>1){} => func(1).over

While I won't be removing the empty block usage any time soon (definitely
not before Sequel 5, and probably never), all users are encouraged to use
the new syntax in new code, as it should be simpler to understand.
Don't quote function names by default on most adapters

PostgreSQL, SQLite, and H2 support quoted function names, but
MySQL, MSSQL, HSQLDB, and Derby do not.  Since Sequel didn't
quote function names in the symbol case, it's safer not to
quote them by default except in the case where it is known
to be supported.