If a field is set to an enum or category type and has a remapping,
that should be cleared if the field moves to a special_type that is
not allowed to have remappings (i.e. text). This commit adds checks
for that and clears the dimension in that case.

The previous commit fixed a bug when there is no order by, but there
is a remapping. The corresponding change to the
add-dimmension-projections-test didn't happen. This fixes that test failure.

When an MBQL query has an order by for a column that has been
remapped via FK, it will swap the order by for the original field for
the remapped field. Previously this would order by the original source
column and apply that to the remapping which would be unexpected.

If we have an external remapping, human_readable_field_id is
required. We now return a 400 if that is missing.

Currently this is used similarly to category. As we get more remapping
features (booleans, strings etc) this will be different from
categories and won't have the existing category baggage.

One of the tests added recently changes the special_type of
category_id. It should have save what it's original value was and
restored it after it was done instead of assuming it's previous value
was nil.

This makes the query_metadata route behavior similar to the field
values route.

This reverts commit 95a65d42.

Specifically updating a field attribute that wasn't it's type or it's
fk_target_field_id would cause this issue

This checks field updates to sniff out when a field is going from an
FK field to something else. If it's no longer an FK field, any
external remapping should be removed as well.

The logic predates remapping, but since remapping used human readable
values, the predicates were kept in place. This commit changes that to
generate field values if it is not present and the user has asked for it.

Added a route for deleting dimensions, and added field_id to the field
values response.

Driver loading previously was very dependent on what code clojure
compiled first. If the Oracle driver was loaded before the plugin
directory was examined, it would result in the Oracle driver never
being loaded. This is due to clojure code only being loaded once when
required and the driver loading code being free floating code that is
only evaled when the namespace is loaded.

This commit switches that code to be in an -init-driver function that
is invoked when the driver is required. This ensures that regardless
of code loading order, the driver will be available if it's present.

This commit also includes code to fail the build if requested to test
on an engine when that engine's driver is not available. Previously if
you set ENGINES to "h2,oracle" but had no Oracle driver in the plugins
directory, the test would succeed, but only test against H2.

This unifies the code and the environment variables for specifying
test database connection parameters across all supported
databases. Existing databases that supported environment variables for
tests have been refactored to use the new environment variable
names. All of the connection environment variables are named similar
to:

MB_<DBNAME>_TEST_<PARAM>

For user on MySQL, the variable would be named:

MB_MYSQL_TEST_USER

Mostly this commit marks test functions as private if their not used
outside of their ns

Tests were failing when attempting to reconcile expected columns with
the actual columns returned. This commit adds code to create a list of
expected columns as the druid query is built.

Specifically added code that matches projections from mongo with the
expected order of results coming back from the database. Also added
code to ensure order by columns are compared correctly after the split
of expand and resolve into two separate middlewares.

This commit adds support for adding dimensions to existing
fields. Values and human readable values (optional) can also be
added/updated.

This commit fixes an issue with Oracle when using remapping, with a
column name that is ambiguous and a limit. Those queries are wrapped
in another query, which will fail in Oracle due to the ambiguous
column name. Columns will not be re-aliased if they collide in Oracle
to prevent this issue. Most of this code was written by
@camsaul (Thanks Cam!).

Previously when java.jdbc renamed a project column (i.e. NAME to
NAME_2) to disambiguate them, we would discard previous information on
that NAME column and reconstruct it based on the data that comes back
from the query. This changes that behavior to update the existing
column data to the new name. When we do not have metadata on that
column it will use the existing behavior to infer that.

This commit also adds some tests for remapping which uncovered this
bug.

This moves values to be nested under the related fields object, and
includes dimension along with human_readable_values in the field as
well.

This commit just defs a map with a default map of key/values for
fields/placeholders/columns and merges that with a map of what's
different for that test.

Fixes up eastwood warnings, add docstrings to public functions

This commit adds logic around an FK remapping found in the
dimensions table. It will follow a foreign key to the related
table and use the indicated column from that table as the remapped
value for the source column.

This commit also switches the "remapped_from" and "remapped_to"
attributes returned in the query response to use the "name" of the
remapped column as there could be ambiguity with the previously used
display name.