Add utf8mb4_0900_ai_ci support

Add utf8mb4_0900_ai_ci supportutf8mb4_0900_ai_ci is the default collation in mysql 8.0.1+
https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_collation_database

It seems that in newer versions of MySQL the charset 76 is used as the
collation for utf8_tolower_ci, and used in the system information catalogs.
Add that in Qmynd.

Fixes https://github.com/dimitri/pgloader/issues/875

Previous patch didn't consider that case doesn't evaluate its branch labels,
so we have to #. (list ...) our constants here. What happened with the
previous coding was that the 'otherwise case would be used always, so that
we only have errors when using BINARY data, basically.

See https://github.com/dimitri/pgloader/issues/716 for such an error case.

In passing, improve the error handling of babel decoding errors by reporting
our own error with information about the MySQL column in which we failed to
read and decode the data. That's pretty useful actually.

As we can see in the details of the bug investigation in
https://github.com/dimitri/pgloader/issues/657, the MySQL protocol may
return an error packet as an answer to opening a connection, before the
initial handshake.

The error packet has the tag 0xff or 255, and Qmynd used to parse it as a
protocol version number. This patch fixes it and introduces a new packet
type 'response-error-no-sql-state', because at this point in the
communication no capabilities are negociated yet, so the error packet does
not contain the SQL state.

Fixes https://github.com/dimitri/pgloader/issues/657.

Handling the different choice combinations within the hot-spot function is
not a very good idea. Instead define four specialized functions and arrange
to pick which to call from upper in the call stack.

Also replace a series of member calls to a simple case form, which is much
simpler to execute.

Good performances results are seen from pgloader side of things. Nothing
spectacular, but every bit counts I guess.

Fixes #10.

In the protocol implementation we use the function read-whole-chunk for
pre-loading data from the network, in a case when we know from the previous
bytes the expected length of the chunk. In case of a partial read, we are
hitting the (Got timeout writing communication packets) MySQL condition.

Trying to finish the partial read gets us nowhere, the communication is
broken. What usually happens instead of resuming the read is an infinite
loop over a CLOSE_WAIT socket.

The wiser choice seems to signal an error with details about the situation
to the user, which is what we do here.

See https://github.com/dimitri/pgloader/issues/420
and https://github.com/dimitri/pgloader/issues/337.

As seen in the following pgloader issue Qmynd implementation of multi
packet MySQL protocol was incomplete and faulty. This patch fixes it to
actually fetch the next packet transparently when needed, which was
always the intend of the code.

In passing, introduce support for the max_allowed_packets idea that is
found in the MySQL configuration, server side, and available in the
default mysql client.

References:

  https://github.com/dimitri/pgloader/issues/328
  https://dev.mysql.com/doc/internals/en/sending-more-than-16mbyte.html

Some level of copy-pasto had to be fixed here.

mysql-local-connection: add implementation for ECL

ECL shares sb-bsd-sockets api with SBCL - this commit adds in
appropriate places ecl to conditional features.

Signed-off-by: Daniel Kochmański <daniel@turtleware.eu>

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.