When one side of a join has an effective predicate expression in terms of the field
use in the join criteria (e.g., v = f(k1), with a join criteria of k1 = k2), and
that expression can produce null on non-null input (e.g., nullif, case, if, most of
the array/map functions, etc), queries can produce incorrect results.

In that scenario, predicate pushdown derives another join condition v = f(k2). Since
f() can produce null on non-null input, it's possible for some value of k1 that's
equal to k2, f(k2) is null or f(k1) is null. This will cause the join criteria to
evaluate to null instead of true.

A correct derivation, although less useful for predicate pushdown,  would be

    k1 = k2 AND ((f(k1) IS NULL AND f(k2) IS NULL) OR f(k1) = f(k2)).

This change prevents the equality inference logic from considering expressions
that may return null on non-null input.

CAST(JSON 'null' AS ...) will also return null

This version avoids allocating arrays that are beyond the JVM limit.

Currently only the ordering column is being printed
in the Explain plan output for Window nodes. It is
also desirable to know what ordering is used for each
of those columns.

Other queries could timeout because they were abandoned causing the test
to fail

Rename fields in ORC dictionary reader to make it clear if the field is
used for the stripe dictionary or row group dictionary.

Always create dictionary blocks in DRWF for columns using a row group
dictionary. This prevents expansion of the dictionary which can create
a very large block.

Simplify the connector materialization of connectors in ConnectorManager

Acquire transaction handle in SystemConnector lazily to avoid accessing
the transaction manager during begin transaction.

This fixes incorrect result for IS DISTINCT FROM between structural
types.

Previously most of the logs were not displayed.
The issue did not affect linux hosts.

This fixes an intermittent failure when the test server took too long to
start

This was an experimental feature that was never used in production
and is not well supported. We don't want to keep carrying that code
around, given how pervasive it is.

CompletableFuture wraps exceptions with CompletionException,
which caused the original PrestoException to be hidden.

This change also fixed the bug that hash operator and hash method
generate different hash codes.

This improvement reduces number of hash computations in a plan
when hash symbols for partitions or joins are the same but
with different order (e.g: Tpch Q9 query).

This reduces GC frequency by ~15% on the coordinator, when using
topology aware scheduling

None of the methods on Metadata return null, and the code was
using the validation constrint @NotNull annotation.

When InMemoryHashAggregationBuilder had no aggregators, it did not
update memory usage (did not call updateMemory). This caused that memory
used groupByHash was not included in stats. This commit fixes that.

InternalJoinFilterFunction is an internal detail of JoinFilterFunction and
should not be exposed to callers. The JoinFilterFuction implementation has
direct access the build pages for performance reasons, and thus can not be
created until the end of the build.  A new JoinFilterFunctionFactory is
added to support this delayed creation.

This simplifies the JoinFilterFunction calling code

This frees up the name for uses of Supplier<LookupSource>

Change lookup source factories to create new instance for each caller.

Always use ParallelHashBuildOperator implementation.
Remove HashBuildOperator.
Rename ParallelHashBuildOperator to HashBuildOperator

The data directory does not contain "local metadata".

These tests are for the engine and are not connector smoke tests.

Throwing and catching exceptions during json encoding was taking up 10-20%
of coordinator CPU

This reduces CPU usage on coordinator by 10% when resource groups are
enabled.

This shows up as a small, but non-zero amount of coordinator CPU, and
seems unnecessary since the scheduler already sets the thread name to the
query being scheduled

This fixes a correctness issue in queries with multiple grouping sets
that resolve to the same set when unaliased. All inputs to
AggregationNode are now written in terms of outputs from GroupIdNode
or ProjectNode. This requires that GroupIdNode look a lot more like
ProjectNode, except that GroupIdNode just copies columns instead of
projecting them.

The isFinished() method for the table scan operators was creating the
page source which is not tracked by Driver. Instead, the page source
should only be created in the getOutput() method.

Now that queries wait for their final info, they're not recorded as
completed until they're finished and their final info has been received.
This wasn't an important part of the test, so just remove it.

Operator specific max memory is no longer used

Before this change, TypedSet used IntBigArray which allocates at least
8KB at initialization, while initialization of IntArrayList only
consumes no more than 256 bytes.

This change might fix the memory limit issues in map_agg and
multimap_agg.

The optimization assumes that symbols used to express the preference
and those used to express the partitioning function for exchanges are
not aliased. When this is not the case, it fails to enforce a
partitioning that is consistent on both branches of the join,
resulting in an incorrect query plan.

This reverts commit 15d32ee.