Concetti SQL per i join

Come in SQL, un join in LookML viene utilizzato per combinare righe di due o più tabelle in base a una colonna correlata tra loro.

In LookML, un'esplorazione, definita dal parametro LookML explore, viene utilizzata per definire in che modo un utente può eseguire query sui dati. Un'esplorazione è costituita da almeno una visualizzazione o da un insieme di visualizzazioni unite tra loro. La visualizzazione principale in Esplora è sempre inclusa nella query. Le viste unite vengono normalmente incluse solo se sono necessarie per soddisfare la query.

Una vista LookML corrisponde a una tabella SQL (o a un altro elemento con la struttura di una tabella) nel database o a una tabella derivata. La vista definisce quali campi o colonne sono disponibili nel database e come accedervi.

L'esempio seguente è una definizione per l'esplorazione di orders.

explore: orders {
  join: users {
    type: left_outer
    sql_on: ${orders.user_id} = ${users.id} ;;
    relationship: many_to_one
  }
}

La visualizzazione orders, che è la visualizzazione principale dell'esplorazione, viene unita alla visualizzazione users con un SQL LEFT OUTER JOIN, come indicato dal parametro LookML type: left_outer. La clausola SQL ON, definita dal parametro LookML sql_on, non utilizza table_alias.column, ma fa riferimento a to ${view_name.field_name}. In questo modo, se il nome della tabella o della colonna cambia nel database, la modifica deve essere apportata solo in un punto.

Il parametro relationship è importante. I join possono causare problemi di fanout in cui le righe vengono duplicate. Se specifichi che molti ordini si uniranno a un solo utente, Looker riconosce che non si verificheranno fanout da questa unione, quindi non è necessario un trattamento speciale. Tuttavia, le relazioni one_to_many possono attivare una distribuzione.

La generazione automatica di visualizzazioni ed esplorazioni prevede per impostazione predefinita un join esterno sinistro. Nell'esempio precedente, tuttavia, è molto probabile che ogni ordine abbia esattamente un utente, quindi il join in questo esempio può essere un inner join.

Per visualizzare l'SQL generato di un'esplorazione, puoi eseguirla nell'interfaccia utente e poi selezionare la scheda SQL nel riquadro Dati.

Ad esempio, se apri l'esplorazione Ordini, definita in precedenza, e poi selezioni i campi User-ID e Conteggio, l'SQL generato sarà simile al seguente:

SELECT
    `user_id` AS `orders.user_id`,
    COUNT(*) AS `orders.count`
FROM
    `thelook`.`orders` AS `orders`
GROUP BY
    1
ORDER BY
    2 DESC
LIMIT 500

In questo esempio, la tabella users non viene mai utilizzata. Viene utilizzato solo se necessario.

Se rimuovi la dimensione User ID e aggiungi la dimensione ID dalla visualizzazione Utenti, l'SQL avrà il seguente aspetto:

SELECT
    `users`.`id` AS `users.id`,
    COUNT(*) AS `orders.count`
FROM
    `thelook`.`orders` AS `orders`
    INNER JOIN `thelook`.`users` AS `users` ON `orders`.`user_id` = `users`.`id`
GROUP BY
    1
ORDER BY
    2 DESC
LIMIT 500

In questo caso, poiché è presente una selezione dalla visualizzazione Utenti, l'unione è inclusa.

L'esempio seguente mostra il codice LookML nel file di esplorazione orders, definito in precedenza, e aggiunge un join alla vista order_items:

explore: orders {
  join: users {
    type: inner
    sql_on: ${orders.user_id} = ${users.id} ;;
    relationship: many_to_one
  }
  join: order_items {
    type: inner
    sql_on: ${orders.id} = ${order_items.order_id} ;;
    relationship: one_to_many
  }
}

Ora, se apri l'esplorazione Ordini nella UI, vedrai la visualizzazione Elementi ordine. Se selezioni la misura Prezzo di vendita totale dalla visualizzazione Elementi ordine insieme a Conteggio da Ordini e ID da Utenti, Looker genera il seguente SQL:

SELECT
    `users`.`id` AS `users.id`,
    COUNT(DISTINCT orders.id ) AS `orders.count`,
    COALESCE(SUM(`order_items`.`sale_price`), 0) AS `order_items.total_sale_price`
FROM
    `thelook`.`orders` AS `orders`
    INNER JOIN `thelook`.`users` AS `users` ON `orders`.`user_id` = `users`.`id`
    INNER JOIN `thelook`.`order_items` AS `order_items` ON `orders`.`id` = `order_items`.`order_id`
GROUP BY
    1
ORDER BY
    2 DESC
LIMIT 500

In questo esempio, COUNT(*) AS orders.count è diventato COUNT(DISTINCT orders.id ) AS orders.count. Looker ha rilevato una possibile situazione di fanout e ha aggiunto automaticamente la parola chiave SQL DISTINCT alla funzione SQL COUNT.