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.