join: Use hash lookup table by default

[jpsamaroo]

This should make joins significantly faster in the common case.

[krynju]

Something like this would work better for me

1. we don't introduce new names by renaming existing args
2. we if once on the l_bigger condition instead of running the if in the hot loop
3. sizehints are correct now (they were missing an if on l_bigger)

let me know what you think

function match_inner_indices(l, r, l_ind::NTuple{N,Int}, r_ind::NTuple{N,Int}) where {N}
    # Use the smaller table to construct the lookup table
    vl, vr = if length(rows(l)) >= length(rows(r))
        match_inner_indices_hash(l, r, l_ind, r_ind)
    else
        match_inner_indices_hash(r, l, r_ind, l_ind)
    end
    return vl, vr
end

function match_inner_indices_hash(l, r, l_ind::NTuple{N,Int}, r_ind::NTuple{N,Int}) where {N}
    # assume left is the bigger table
    # Construct the lookup table
    row_tuple = (row, cols) -> ([getcolumn(row, x) for x in cols]...,)
    row_type = Base.to_tuple_type([eltype(getcolumn(r, ind)) for ind in r_ind])
    lookup = Dict{row_type,Vector{UInt}}()
    for (idx, row) in enumerate(rows(r))
        key = row_tuple(row, r_ind)
        idxs = get!(Vector{UInt}, lookup, key)
        push!(idxs, idx)
    end

    # Find rows in the larger (probe) table that match with the build table entries
    l_length = length(rows(l))
    vl = Vector{UInt}()
    vr = Vector{UInt}()
    sizehint!(vl, l_length)
    sizehint!(vr, l_length)

    for (idx, row) in enumerate(rows(l))
        key = row_tuple(row, l_ind)
        if haskey(lookup, key)
            build_idxs = lookup[key]
            for build_idx in build_idxs
                push!(vl, idx)
                push!(vr, build_idx)
            end
        end
    end

    return vl, vr
end