The swift adapters now require swift-db-* instead of swift itself (Fixes #526)

This is a squashed commit of Pull Request 526, along with some
local changes by me, including:

* Using :pass instead of :password so that connections that require
  passwords work.

* Requiring the swift-db adapter instead the subadapter instead
  of the main adapter proc.

* Adding appropriate guards to the specs.  Currently, hstore
  ? operators are broken on swift/postgres just like on do/postgres.
  Also, swift/sqlite is not completely stable, so add guards for
  the specs that cause it to crash (see
  https://github.com/deepfryed/swift-db-sqlite3/issues/1 for details).

One good thing about this change is that with the swift-db-*
adapters, you only need to install the related gem, you don't need
to install dbic++.
Make swift/postgres adapter work with hstore, requires swift-db-postgres 0.2.0+

This sets the native_bind_format setting which causes
swift-db-postgres not to do the ? -> $n conversion that breaks
the hstore ? operator.
Remove some spec guards related to swift

Some of the swift/sqlite specific ones were added recently to
work around memory issues in swift-db-sqlite3, which have been
fixed in version 0.1.2.  Others also appear to be run correctly
and should be enabled.
MySql types 'double(x,x)', 'double(x,x) unsigned' support added.
Add a > 0 check for double(x, y) unsigned

This is already done for unsigned integers and bignums, so it makes
sense to do so for double as well.
Bump version to 3.38.0
Recognize MySQL set type and default value (Fixes #529)

While here, refactor column_schema_to_ruby_default to not check
for database types.  Instead, override the method and call
super inside the shared adapters.

Instead of supporting set for all databases, only add it to the
shared mysql adapter.  Likewise, since interval is only supported
on PostgreSQL, move support for it to the shared postgres adapter.

For simplicity, still recognize the :set and :interval type symbols
in the global code in order to return the default values as a ruby
string, though that may be refactored out to the adapters later.

While here, do some minor cleaning up of the postgres adapter specs.
Make identity_map plugin work with models lacking a primary key

Such models cannot use an identity map, but this at least doesn't
break them if you load the identity_map plugin globally.

This changes identity_map_key to be nil instead of a random string,
and makes all callers check for nil return nils before acting on
the identity map.
Add Postgres::PGRowOp#* for referencing the members of the composite type as separate columns

This acts differently than the #splat method, though the resulting
syntax is similar.  splat is for when you want to make sure you
are referencing a table as the table's composite type, usually
necessary when the table has the same name as one of its columns.
* is for referencing the members of the composite type as separate
columns.

The * method definition is copied from QualifyingMethods.
Unfortunately, the qualify method doesn't make sense for PGRowOp,
otherwise I would have just included the QualifyingMethods module.
Add :connection_handling=>:disconnect option for threaded connection pools

This option always disconnects the connection, instead of returning
it to the pool.  The expected use case is for people who want to
manually control all checkouts.

For example, let's say you have a web application that modifies
the connection state in each action.  You don't want a connection
used by one action to be used by another action, since you don't
know the state of the connection.  Also, later queries in the same
action may depend upon the state of the connection set previously
in the action, so you need to use a consistent connection for the
entire action.  In this case, a rack middleware that used
Database#synchronize around each action and used
:connection_handling=>:disconnect when connecting should work.
Add :where option to validates_unique, for custom uniqueness filters

validates_unique already takes a block, but the block is used for
scoping the existing uniqueness filter to a subset of the model's
dataset (for example, only validating uniqueness for active users
as opposed to all users).  This doesn't allow you to change the
actual filter used for uniqueness, which is necessary if you want
to do a case insensitive uniqueness validation for a database
that is case sensitive by default.

The :where option is used instead of the default filter, allowing
custom uniqueness checks.  In addition to case insensitive
uniqueness validations, it probably could be used for validations
of PostgreSQL exclusion constraints.
Allow subclasses plugin to take a block, which is called with all subclasses created

This is useful if you are creating subclasses at runtime.
Previously, if you wanted to make a specific change on a per
class basis to each subclass, you would have had to
periodically check descendents and look for new classes.
With this change, you can easily make such a change as soon
as the subclass is created.
Cleanup created tables in the integration tests
Cleanup created tables in the mysql, mssql, postgres, and sqlite adapter specs
Add bin/sequel -c support, for running code string instead of using an IRB prompt

You could previously have done this by piping the code to the
standard input, but this is definitely easier.  Would have
preferred to use the -e option so that executing code is similar
to ruby, but since that was taken, I choose to use -c since that
is similar to sh.
Cleanup created tables in the oracle adapter specs
Fix validation_helpers spec after code change
More cleanup in the oracle adapter specs
Make Time->DateTime and DateTime->Time typecasts retain fractional seconds on ruby 1.8 (Fixes #531)

On ruby 1.9, the typecasts just use Time#to_datetime and
DateTime#to_time, but those methods aren't available in ruby 1.8.
On ruby 1.8, a conversion is done through string, but that wasn't
including the fractional seconds.  Manually include the fractional
seconds for both type conversions on ruby 1.8.
Refactor postgres adapter to work with new sequel_pg streaming

PostgreSQL removed the streaming support added in 9.2beta1, and
replaced it with a different API in 9.2beta3. The new API
uses separate PGresult objects for each row, so in those
cases, the connection execute methods return the connection
itself instead of a PGresult object.  Since the returned object
may not respond to clear, only clear it if it responds.

The _execute_prepared_statement method is being split off for
easier overriding.