I join ti consentono di collegare visualizzazioni diverse in modo da poter esplorare i dati di più viste contemporaneamente e vedere la relazione esistente tra le diverse parti dei tuoi dati.
Ad esempio, il database potrebbe includere le tabelle order_items, orders e users. Puoi utilizzare le unioni per esplorare i dati da tutte le tabelle contemporaneamente. Questa pagina spiega le unioni in LookML, inclusi parametri di unione specifici e pattern di unione.
La partecipazione inizia con un'esplorazione
Le unioni sono definite nel file modello per stabilire la relazione tra un esplorazione e una vista. I join collegano una o più viste a una singola esplorazione, direttamente o tramite un'altra visualizzazione unita.
Prendiamo in considerazione due tabelle di database: order_items e orders. Dopo aver generato visualizzazioni per entrambe le tabelle, dichiarane una o più con il parametro explore nel file modello:
explore: order_items { ... }
Quando esegui una query dall'area di esplorazione di order_items, order_items viene visualizzato nella clausola FROM dell'SQL generato:
SELECT ...
FROM order_items
Puoi saperne di più nella pagina Esplora di order_items. Ad esempio, per aggiungere dati relativi a order di cui order_item fa parte, puoi:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
Il codice LookML riportato sopra consente di eseguire due operazioni. Innanzitutto, puoi visualizzare i campi sia di orders che di order_items nell'interfaccia utente:
In secondo luogo, il LookML descrive come unire orders e order_items insieme. Tale LookML tradurrebbe nel seguente SQL:
SELECT ...
FROM order_items
LEFT JOIN orders
ON order_items.order_id = orders.id
Questi parametri LookML sono descritti in maggiore dettaglio nelle sezioni seguenti. Consulta la pagina di riferimento del parametro join per ulteriori informazioni su come questo LookML viene tradotto in SQL.
Suggerimento per il team di Chat: gli utenti chiedono di più sull'errore di convalida, "Campo sconosciuto o inaccessibile", che può essere causato da un join mancante. Per scoprire di più, consulta l'articolo del Centro assistenza relativo a questo errore.
Parametri di join
Per l'unione sono utilizzati quattro parametri principali: joins, join, type, relationship e sql_on.
Passaggio 1: avvia l'esplorazione
Innanzitutto, crea l'esplorazione di order_items:
explore: order_items { ... }
Passaggio 2: join
Per unire una tabella, devi prima dichiararla in una vista. In questo esempio, orders è una vista esistente nel nostro modello.
Quindi, utilizza il parametro join per dichiarare che vuoi unire la vista orders a order_items:
explore: order_items {
join: orders { ... }
}
Passaggio 3: type
Valuta quale type di cui eseguire l'iscrizione. Looker supporta LEFT JOIN, INNER JOIN, FULL OUTER JOIN e CROSS JOIN. Corrisponde ai valori dei parametri type di left_outer, inner, full_outer e cross.
explore: order_items {
join: orders {
type: left_outer
}
}
Il valore predefinito di type è left_outer e in genere è il tipo di unione più utilizzato.
Passaggio 4. relationship
Definisci un join relationship tra order_items e orders. È importante dichiarare correttamente relationship di un join. La relazione è definita da order_items Esplorazione a vista orders. Le opzioni possibili sono one_to_one, many_to_one, one_to_many e many_to_many.
In questo esempio, possono esserci molti order_items per una singola order. La relazione da order_items a orders è many_to_one:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
}
}
Se non includi un elemento relationship nel join, Looker avrà l'impostazione predefinita many_to_one.
Per ulteriori suggerimenti su come definire correttamente il parametro relationship per un join, consulta l'articolo del Centro assistenza Parametro relationship corretto.
Passaggio 5. sql_on
Dichiara come unire queste due tabelle con il parametro sql_on o foreign_key. In genere, consigliamo sql_on perché può fare tutto ciò che foreign_key può fare, ma in genere è più facile da capire.
sql_on è equivalente alla clausola ON nell'SQL generato per una query. Con questo parametro, possiamo dichiarare quali campi devono essere abbinati per eseguire l'unione:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
}
Puoi anche scrivere un join più complesso. Ad esempio, potresti voler unire solo gli ordini con id maggiori di 1000:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} AND ${orders.id} > 1000 ;;
}
}
Consulta gli operatori di sostituzione per saperne di più sulla sintassi ${ ... } in questi esempi.
Passaggio 6: test
Verifica che questa unione funzioni come previsto nella sezione Esplora gli ordini della pagina Esplora. Dovresti visualizzare i campi sia di order_items che di orders.
Per ulteriori informazioni sui test delle modifiche di LookML, consulta Sviluppo del modello.
Partecipazione tramite un'altra visualizzazione
Puoi unire una vista a un'esplorazione tramite un'altra visualizzazione. Nell'esempio precedente, hai eseguito la registrazione a orders a order_items tramite il campo order_id. Potremmo anche voler unire i dati di una vista chiamata users all'esplorazione di order_items, anche se non condividono un campo comune. A tal fine, puoi unirti tramite la vista orders.
Utilizza sql_on o foreign_key per unire users a orders anziché a order_items. Per farlo, definisci l'ambito del campo da orders come orders.user_id.
Ecco un esempio con l'utilizzo di sql_on:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
join: users {
type: left_outer
relationship: many_to_one
sql_on: ${orders.user_id} = ${users.id} ;;
}
}
Unire una visualizzazione più di una volta
Una vista users contiene dati sia per gli acquirenti che per i venditori. Per unire i dati di questa vista a order_items, ma fallo separatamente per acquirenti e venditori, puoi unire users due volte, con nomi diversi, utilizzando il parametro from.
Il parametro from consente di specificare quale vista utilizzare in un join, assegnando al contempo un nome univoco. Ad esempio:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
}
join: buyers {
from: users
type: left_outer
relationship: many_to_one
sql_on: ${orders.buyer_id} = ${buyers.id} ;;
}
join: sellers {
from: users
type: left_outer
relationship: many_to_one
sql_on: ${orders.seller_id} = ${sellers.id} ;;
}
}
In questo caso, solo i dati di acquirente vengono uniti come buyers, mentre solo i dati di venditore sono uniti come sellers.
Nota: ora la vista users deve essere indicata con i relativi nomi alias buyers e sellers nel join.
Limitazione dei campi da un join
Il parametro fields ti consente di specificare quali campi vengono trasferiti da un join a un'esplorazione. Per impostazione predefinita, tutti i campi di una vista vengono inseriti quando vengono uniti. Tuttavia, potresti voler visualizzare solo un sottoinsieme di campi.
Ad esempio, quando orders fa parte di order_items, potresti voler trasferire solo i campi shipping e tax tramite il join:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
fields: [shipping, tax]
}
}
Puoi anche fare riferimento a un insieme di campi, ad esempio [set_a*]. Ogni insieme viene definito in una vista utilizzando il parametro set. Supponiamo che nella vista orders sia definito il seguente insieme:
set: orders_set {
fields: [created_date, shipping, tax]
}
Puoi scegliere di trasferire solo questi tre campi quando partecipi a orders per order_items:
explore: order_items {
join: orders {
type: left_outer
relationship: many_to_one
sql_on: ${order_items.order_id} = ${orders.id} ;;
fields: [orders_set*]
}
}
Aggregati simmetrici
Looker utilizza una funzionalità denominata "aggregati simmetrici" per calcolare correttamente le aggregazioni (come somme e medie), anche quando le unioni generano una fanout. Gli aggregati simmetrici sono descritti in modo più dettagliato nell'articolo del Centro assistenza Una semplice spiegazione degli aggregati simmetrici e il problema di fanout che risolve è spiegato nell'articolo Il problema delle fanout SQL.
Chiavi primarie necessarie
Per fare in modo che le misure (aggregazioni) arrivino tramite join, devi definire le chiavi primarie in tutte le viste coinvolte nel join.
A tale scopo, aggiungi il parametro primary_key alla definizione del campo della chiave primaria in ogni vista:
dimension: id {
type: number
primary_key: yes
}
Per gestire correttamente le misure combinate, Looker ti affida a te specificando una chiave primaria in cui i valori sono completamente univoci e non NULL. Se i dati non contengono una chiave primaria, valuta se la concatenazione di diversi campi genera una chiave primaria di valori completamente non univoci. Se la chiave primaria non è univoca o contiene valori NULL e la query include dati che rivelano questi problemi, Looker restituisce un errore come descritto in questo articolo del Centro assistenza.
Dialetti SQL supportati
Affinché Looker supporti gli aggregati simmetrici nel tuo progetto Looker, anche il tuo dialetto del database deve supportarli. La tabella seguente mostra quali dialetti supportano gli aggregati simmetrici nell'ultima release di Looker:
Se il tuo dialetto non supporta gli aggregati simmetrici, fai attenzione quando esegui un join in Looker, poiché alcuni tipi di join possono causare aggregazioni imprecise (come somme e medie). Questo problema e le relative soluzioni sono descritti in dettaglio nell'articolo del Centro assistenza Il problema dei fanout di SQL.
Scopri di più sulle unioni
Per scoprire di più sui parametri di unione in LookML, consulta la documentazione Unisci riferimento.