Rather than looping over read-my-octet use replace to load a packet at a
time into the destination sequence. It should be faster that way,
although preliminary testing here shows no gain.

See https://github.com/dimitri/pgloader/issues/247 for context.

The my-packet-stream structure doesn't just represent a MySQL protocol
packet, it also has a payload that may expand more than a single
packet (see 5.1.2.1 Big packets).

That fixes https://github.com/dimitri/pgloader/issues/247 for me.

also support VARBINARY columns

It's now a key parameter in the connection API and defaults to nil so
that it's possible to connect to older MySQL servers lacking that
feature.

Should fix https://github.com/dimitri/pgloader/issues/95.

MySQL sends BLOB and TEXT types under the same column types in the
protocol, as per the following documentation:

  http://dev.mysql.com/doc/internals/en/com-query-response.html#column-type

As we can see in https://github.com/dimitri/pgloader/issues/106 it was
wrong to mix the special character set +mysql-cs-coll-binary+ used to
decide if we just received binary or text data with other _bin
collaction, used for something else entirely, as detailed in:

  http://dev.mysql.com/doc/refman/5.0/en/blob.html

See https://github.com/dimitri/pgloader/issues/95 for another use case
where supporting mixed password policies is needed.

Fix to be able to use prepare-statement.

Change to manipulate the return value of mysql-read-packet as my-stream-stream not as sequence.

This function was mixing several levels of API to access to packet
chunks contents and as a result was infinitely looping over a
read-sequence call that would make no progress in the "Access denied"
protocol error case.

It so happens that MySQL stores data in an encoding that is different
from what it knows in the meta-data, and that the application knows the
real data encoding. With that dynamic binding it's now possible to force
the Qmynd driver using the known data encoding, which might very well be
different from the meta-data.

Provide restarts in case of string decoding errors.

Fix encoding related bugs.

In particular, force our prefered encoding in the connection rather than
rely on whatever the server setup is: we know babel can handle utf8.

Fix comparing the column cs-coll and encodings in as-text mode.

This makes it less confusing for a Lisp hacker,
because a Lisp byte need not be an MySQL byte, but an octet is;
and a Lisp string is very different from a MySQL string, which is octets.

Add two utilities. Export assert-equal-helper from qtest.

The qmynd wire-protocol implementation was eagerly loading up the whole
content of a MySQL packet as a sequence of unsigned-bytes in memory, only to
then read from a stream built on-top of that sequence.

The new wire-packet implementation is a transparent stream where the next
packet's chunk is crossed transparently from within read-my-byte and
read-my-sequence calls, resulting in only fetching the data we need at any
time and bypassing all the stream to sequence of bytes to stream again in
the parsing of the data.

In passing, we also fix the handling of data as text.

Tests ran against this code show it about twice as fast as the previous
coding in best cases, and when disabling compression. There's now an option
to disable it at connection time (default to disable), because it's
unexpected to see compression offering any gain on a "local" connection
anyway, even more when using salza and chipz.

The sense of the signed bit in the type stream was reversed

Conflicts:
	src/common/conditions.lisp
	src/wire-protocol/basic-types.lisp