Order SQL::Expression attr_reader calls by position in initialize method
Add eval_inspect extension, which makes Sequel::SQL::Expression#inspect attempt to return a string suitable for eval

This extension is definitely not bullet proof, as there are a lot
of cases it does not handle.  However, in most simple cases it
allows you to take an arbitrary Sequel expression and have
inspect on it return a string that when evaled will produce an
equivalent object.
Remove type conversion of int2vector and money types on PostgreSQL, since previous conversions were wrong

int2vector types were converted with to a single integer, and money
types (at least for the US locale) were converted to a BigDecimal
with value 0.0.
Generalize handling of array types in the pg_array extension, allowing easy support of custom array types

This adds that Sequel::Postgres::PGArray.register method which
allows you to register custom array types.  It removes all of
the PGArray subclasses, since the subclasses were only used
for parsing, and refactors the implementation so that instead
of using class methods for parsing, instances of another class
(either Creator or JSONCreator are used).  Sequel doesn't usually
pay much attention to "favor composition over inheritance", but in
this case, switching to composition is much better, since with
the old style, each array type would require a separate class.

Some other changes made here:

* Move PG_TYPES code from the native postgres adapter to its own
  file that both the native postgres adapter and the pg_array
  extension load.

* No longer use the JSON parser for floating point types, since it
  doesn't handle NaN and Infinity values correctly.

* Convert PGArray types when typecasting if they don't use the
  same array type.

* Suppport arrays types for all of the scalar types that the
  native Sequel adapter supports, including boolean, bytea, date
  time, and timestamp array types.

* Since Creator and JSONCreator instances are callable objects, they
  can be directly set in PG_TYPES, avoiding the need to create
  separate conversion lambda procs.
Fix schema parsing of h2 clob types

H2 uses uppercase types, so make sure to downcase them when comparing.
Make the pg_json extension handle json[] type when used with the pg_array extension

This uses the new features of the pg_array extension so that
the json[] type can be supported.
Handle Sequel::SQL::Blob values in bytea[] bound variables

While here, also handle Sequel::LiteralString values in bound
variables.
Make the pg_inet extension handle inet[]/cidr[]/macaddr[] types when used with the pg_array extension

Similar to the recent changes to the pg_json extension.
Make jdbc/postgres adapter convert array type elements (e.g. date[] arrays are returned as arrays of Date instances)

Before, the conversion proc would recursively map the array so that
all subarrays where turned into ruby arrays.  However, it would
not do any value conversion, so date[] arrays would be returned
as ruby arrays with Java::JavaSQL::Date instances.  Refactor this
to use a separate converter instance per array column, that uses
the standard scalar type conversion to convert elements of the
array.

Refactor specs so that some basic tests of this feature are run
on jdbc.  Unfortunately, it looks like not all types are handled,
so change the tests so that only the cases the jdbc/postgres
adapter currently handles are run on jdbc/postgres.

This is not backwards compatible if you were relying on the
jdbc/postgres array typecasting internals.
Added line to show how to load the extension before use in a model, as I haven't seen that documented elsewhere (for this particular extension).
Add Sequel.recursive_map

I'm moving this method from PGArray::JSONCreator to Sequel, since
I'm planning on reusing it elsewhere.  This method is not
designed for public use, but it's a public method so I don't have
to use send to call it.
Add default typecasting of timestamp datatypes to pg_types.rb

These are handled specially in the native postgres adapter so
that they can work with Database-specific timezones, but
providing a useful default is important.
Make pg_types.rb not depend on native postgres adapter

Before, the bytea type conversion proc depended on the native
adapter.  Move that handling back into the native postgres
adapter, and have some default code that uses the pure ruby
bytea unescaping from my fork of postgres-pr.
Convert scalar types when typecasting Array to PGArray

Before, if an array object was passed to the type conversion
method, it was just wrapped in a PGArray.  Now in most cases
it will be converted using a recursive map and the appropriate
typecasting method.  In most cases it can pick the correct
method by default, but the :scalar_typecast option was added
so a specific method can be chosen.

For example, if you have an date[] field, you can pass an array
of strings (i.e. from a web form) to the setter, and it will
be typecasted to a PGArray of ruby Date objects.

This is implemented by having typecast_value_pg_array take an
optional third argument indicating the method to use for
typecasting scalars.

While here, refactor the tests so it tests conversions for
most array types that the extension supports.
Add pg_range extension, for dealing with PostgreSQL 9.2+ range types

Range types are a new feature in PostgreSQL 9.2.  They are similar
to ruby's Range class, but significantly more flexible.  Because
not all PostgreSQL Ranges can be converted to ruby Range objects,
the PGRange class is not a DelegateClass of Range, but a plain
subclass of Object.  However, in many cases it acts similarly to
a delegate class, as least if the PGRange can be represented by
a ruby Range.  Otherwise, this extension is similar to the other
Sequel pg_* extensions.
Utitilize an existing dataset limit when updating on Microsoft SQL Server

This is supported since MSSQL 2005.  Before, Sequel would just
ignore the limit.
Add Database#extension and Dataset#extension for loading extension modules into objects automatically

This should make it easier to use some extensions.  Instead of
loading the extension with Sequel.extension and then manually
calling extend with full path of the extension module, you can
just call extension on the object with the extension name, and
it will require the extension and load the appropriate module.
Add split_array_nil extension, for compiling :col=>[1, nil] to col IN (1) OR col IS NULL

This has been requested a couple times in the last year.  I don't
think it's a good idea by default, which is why it's being
implemented as an extension.
Fix typo in split_array_nil docs, spotted by markiz
Added info to docs on how to load an extension.