Merge x.38.1 part 1

0.39 improve custom expression

v0.38.0.1

the plugin raises an error on anything that looks like a hook (a
function that starts with "use") so am disabling eslint for two false
positives

Update Redshift driver to 2.0.0.3

Support controlling JDBC fetch size for Redshift

Adding `defaultRowFetchSize` parameter for JDBC URL in Redshift driver, which controls the `fetchSize` for all `PreparedStatement` instances created under it

Adding environment variable for controlling the new `redshift-fetch-size` parameter

Adding documentation for aforementioned new env var

Adding test for both the JDBC URL, as well as the `fetchSize` of the `PreparedStatement` itself

* Fix pivot table queries w/o data permissions

* Text fix 

* Refactor

* Ns sorting

* Custom expression completion: test that "case" is offered as a choice

* Remove Cypress alias

* Enable the test for arithmetic inside a filter

This is now working after the feature implementation (#14325)

* Use a better Cypress syntax

* Add some positive assertion

These new functions are to support MBQL's is-null and is-empty.

Use the compact syntax tree in the type checker to easily constrain the
type for each argument in a function/case expression. This will lead to
a correct resolve for every dimension/metric/segment in that subtree
associated with each argument.

* Custom expression: build a compact version of the syntax tree

The Chevrotain-based parser produces a very verbose syntax tree
(matching the grammar productions on every step of the way).
For instance, a custom expression as simple as "1" results in
the following tree:

```
(root)
  expression
    relationalExpression
      additionExpression
        multiplicationExpression
          atomicExpression
            numberLiteral
```

This makes it hard for type-checker to perform its analysis, due to the
need to traverse deeply every one of its children (even if there is only
one direct child).

The compact syntax tree can be constructed from the above
representation, which trims the unnecessary intermediate nodes:

```
(root)
  numberLiteral
```

Since it is used a placeholder for a dimension, a metric, or a segment
(resolving to one of them is delegated to the compiler), it makes sense
to use a more generic and less confusing name.

The core logic of MBQL compiler only has an abstract understanding of
the environment access (fields like segments, dimensions, and metrics)
as resolving those can be delegated accordingly.

As a bonus, this makes it very easy to test and to refactor the compiler
code.

The previous grammar revamp finally allowed some complex expression
constructs.

* Revamp the grammar of custom expression

Handle logical operations (AND, OR, NOT) by having them as part of the
grammar productions/rules, instead of only as special cases of
filters/aggregations.

This finally allows any arithmetic operations inside a filter. In fact,
this lets the correct mix-up between any logical and arithmetic
operations (including function calls), also by leveraging the type
checker to determine the correct type constraints for the terminals (Booleans,
expressions, dimensions, metrics, segments, etc).

* Be more explicit about skipped (known) regression

Use the type-checker to dynamically resolve dimensions as metrics,
wherever it is constrained in the right sub-tree for an aggregation.

Use the type checker for dynamic resolving of an identifier, i.e. to infer
whether it represents a dimension or a segment, based on the type
constraints in the sub-expression.
This also eliminates the flawed type-based resolving which happens
during the parsing time.

* Add a barebone type checker for the expression parser

* Add more context and other review feedback

* Custom expression parser: formalize the tree visitor

Also included, a pretty-printer to debug the syntax tree.

* Simplify the tree's pretty printer

Switch query execution to use `Statement` instead of `PreparedStatement` when there are no params

Add new multimethod to create a `Statement`, rather than `PreparedStatement`, which works similarly, called `statement`

Add new multimethod to run a SQL query against a Statement, similar to `execute-query!`, called `execute-statement!`

For consistency, rename `execute-query!` to `execute-prepared-statement!`

Change `execute-reducible-query` to capture whether the query has params, and if not, using the new multimethods instead

Update fetch-results-metadata-test so it replaces execute-select! instead of prepared-statement

Adding `statement-supported?` multimethod (defaults to true), to let drivers control whether statements are used at all

Updating Oracle driver to not override holdability for `statement`, similar to `prepared-statement`, and bumping module version

Updating SparkSQL driver to indicate that statements are not supported, and bumping module version

Fixing Redshift test to also override `execute-statement!` so it can capture the SQL for a statement

* obey those number separator settings

* make it lint

* Adding the ability to sync admin groups in EE

Adds a LDAP setting for EE to enable to LDAP Administrator group syncs.

Adds the setting to admin UI to enable syncing of the admin group.

Removes two unused settings from the OSS side.

metabase/metabase-enterprise#445

* Apply suggestions from code review

Co-authored-by: Dalton <daltojohnso@users.noreply.github.com>

Co-authored-by: Dalton <daltojohnso@users.noreply.github.com>