Spark SQL che esegue il join cartesiano invece del join interno

Question

Sto provando ad unire due DataFrame l'uno con l'altro dopo aver eseguito alcuni calcoli precedenti. Il comando è semplice:

employee.join(employer, employee("id") === employer("id")) 

Tuttavia, il join sembra per eseguire cartesiani unirsi, ignorando completamente la mia dichiarazione ===. Qualcuno ha un'idea perché sta succedendo?

Answer 1

Penso di aver combattuto con lo stesso problema. Verificare se si dispone di un avviso:

Constructing trivially true equals predicate [..] 

Dopo aver creato l'operazione di join. In tal caso, è sufficiente inserire alias una delle colonne in DataFrame dipendente o dipendente, ad es. in questo modo:

employee.select(<columns you want>, employee("id").as("id_e")) 

Poi eseguire unirsi su employee("id_e") === employer("id").

Spiegazione. Guardate questo flusso operazione:

Se si utilizza direttamente il tuo dataframe A per calcolare dataframe B e unirsi a loro insieme sulla colonna ID, che viene dal dataframe A, non sarà eseguendo il unisciti a te che vuoi fare. La colonna ID di DataFrameB è in effetti la stessa identica colonna di DataFrameA, quindi la scintilla semplicemente asserirà che la colonna è uguale a se stessa e quindi al predicato banalmente vero. Per evitare ciò, devi creare alias una delle colonne in modo che appaiano come colonne "diverse" per la scintilla. Per ora solo il messaggio di avviso è stata implementata in questo modo:

def === (other: Any): Column = { 
    val right = lit(other).expr 
    if (this.expr == right) { 
     logWarning(
     s"Constructing trivially true equals predicate, '${this.expr} = $right'. " + 
      "Perhaps you need to use aliases.") 
    } 
    EqualTo(expr, right) 
    } 

Non è una soluzione soluzione molto buona per me (in realtà è facile perdere il messaggio di avviso), spero che questo sarà in qualche modo risolto.

Sei fortunato però a vedere il messaggio di avviso, it has been added not so long ago;).