Utilizzo dei join in LookML

I join ti consentono di collegare viste diverse in modo da poter esplorare i dati di più viste contemporaneamente e vedere come le diverse parti dei dati sono correlate tra loro.

Ad esempio, il database potrebbe includere le tabelle order_items, orders e users. Puoi utilizzare i join per esplorare i dati di tutte le tabelle contemporaneamente. Questa pagina illustra i join in LookML, inclusi parametri di join specifici e pattern di unione.

Le unioni iniziano con un'esplorazione

I join sono definiti nel file del 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 vista unita.

Considera due tabelle di database: order_items e orders. Dopo aver generato visualizzazioni per entrambe le tabelle, dichiarane una o più nel parametro explore del file del modello:

explore: order_items { ... }

Quando esegui una query dall'esplorazione order_items, order_items viene visualizzato nella clausola FROM dell'SQL generato:

SELECT ...
FROM order_items

Puoi unire ulteriori informazioni all'esplorazione order_items. Ad esempio, puoi utilizzare il seguente LookML di esempio per unire la vista orders all'esplorazione order_items:

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

Il LookML mostrato in precedenza svolge due cose. Innanzitutto, puoi visualizzare i campi sia di orders che di order_items nel selettore dei campi Esplora:

In secondo luogo, LookML descrive come unire orders e order_items. Questo tipo di LookML si 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.

Suggerimento per il team di Chat: gli utenti chiedono più informazioni in merito all'errore di convalida, "Campo sconosciuto o inaccessibile", che può essere causato da un join mancante. Per ulteriori informazioni, consulta Errore: campo sconosciuto o inaccessibile.

Parametri di join

Per l'unione vengono utilizzati quattro parametri principali: join, type, relationship e sql_on.

Passaggio 1: avvio dell'esplorazione

Per prima cosa, crea l'esplorazione order_items:

explore: order_items { ... }

Passaggio 2: join

Per unire una tabella, devi prima dichiarare la tabella in una vista. In questo esempio, supponiamo che orders sia una vista esistente nel modello.

Poi, utilizza il parametro join per dichiarare che vuoi unire la vista orders all'esplorazione order_items:

explore: order_items {
  join: orders { ... }
}

Passaggio 3: type

Valuta quale tipo di join eseguire. Looker supporta LEFT JOIN, INNER JOIN, FULL OUTER JOIN e CROSS JOIN. Corrisponde ai valori parametro type di left_outer, inner, full_outer e cross.

explore: order_items {
  join: orders {
    type: left_outer
  }
}

Il valore predefinito di type è left_outer.

Passaggio 4: relationship

Definisci una relazione di unione tra l'esplorazione order_items e la vista orders. Dichiarare correttamente la relazione di un join è importante per consentire a Looker di calcolare misure precise. La relazione viene definita da l'esplorazione order_items alla vista orders. Le opzioni possibili sono one_to_one, many_to_one, one_to_many e many_to_many.

In questo esempio possono essere presenti più articoli per un singolo ordine. La relazione tra l'esplorazione di order_items e la visualizzazione orders è many_to_one:

explore: order_items {
  join: orders {
    type: left_outer
    relationship: many_to_one
  }
}

Se non includi un parametro relationship nel join, il valore predefinito di Looker sarà many_to_one.

Per ulteriori suggerimenti su come definire correttamente il parametro relationship per un join, consulta l'articolo Ottenere il parametro relationship corretto.

Passaggio 5: sql_on

Dichiara come unire la tabella order_items e la tabella orders con il parametro sql_on o foreign_key.

Suggerimento: in genere consigliamo di utilizzare il parametro sql_on poiché ha le stesse funzionalità del parametro foreign_key, ma in genere il parametro sql_on è più facile da comprendere.

Il parametro sql_on equivale alla clausola ON nell'SQL generato per una query. Con questo parametro, puoi dichiarare i campi da associare 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 join più complessi. Ad esempio, potresti voler unire solo ordini con id maggiore 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 ;;
  }
}

Per saperne di più sulla sintassi ${ ... } in questi esempi, consulta la documentazione sugli operatori di sostituzione.

Passaggio 6: test

Verifica che questo join funzioni come previsto accedendo all'esplorazione Articoli dell'ordine. Dovresti vedere i campi sia di order_items che di orders.

Per saperne di più sul test delle modifiche LookML in un'esplorazione, consulta Modifica e convalida di LookML.

Partecipazione tramite un'altra vista

Puoi unire una vista a un'esplorazione tramite un'altra vista. Nell'esempio precedente, hai unito orders a order_items tramite il campo order_id. Potremmo anche unire i dati di una vista denominata users all'esplorazione di order_items, anche se non condividono un campo comune. Per farlo, accedi tramite la vista orders.

Utilizza il parametro sql_on o il parametro foreign_key per unire la vista users alla vista orders, anziché all'esplorazione order_items. Per farlo, identifica correttamente l'ambito del campo da orders come orders.user_id.

Ecco un esempio in cui viene utilizzato il parametro 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} ;;
  }
}

Partecipare più volte a una visualizzazione

Una vista users contiene dati sia per gli acquirenti che per i venditori. Per unire i dati di questa visualizzazione in order_items, ma separatamente per acquirenti e venditori, puoi unire users due volte, con nomi diversi, utilizzando il parametro from.

Il parametro from ti consente di specificare la visualizzazione da utilizzare in un join, assegnandogli 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 dell'acquirente vengono uniti come buyers, mentre solo i dati del venditore vengono uniti come sellers.

Nota: ora nella vista users devi fare riferimento ai relativi nomi con alias buyers e sellers nel join.

Limitazione dei campi di un join

Il parametro fields consente di specificare quali campi vengono trasferiti da un join a un'esplorazione. Per impostazione predefinita, tutti i campi di una vista vengono visualizzati una volta uniti. Tuttavia, potresti voler visualizzare solo un sottoinsieme di campi.

Ad esempio, quando orders viene unito a order_items, potresti voler portare 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 all'interno di una vista utilizzando il parametro set. Supponi di aver definito il seguente insieme nella vista orders:

set: orders_set {
  fields: [created_date, shipping, tax]
}

Puoi scegliere di visualizzare solo questi tre campi quando unisci orders a 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*]
  }
}

Dati aggregati simmetrici

Looker utilizza una funzionalità chiamata "aggregazioni simmetriche" per calcolare correttamente le aggregazioni (come somme e medie), anche quando i join generano un fanout. I dati aggregati simmetrici sono descritti più dettagliatamente nella pagina Comprensione dei dati aggregati simmetrici. Il problema del fanout risolto dai gruppi simmetriati è spiegato nel post della scheda Community Il problema dei fanout SQL.

Chiavi primarie obbligatorie

Per fare in modo che le misure (aggregazioni) provengano tramite join, devi definire le chiavi primarie in tutte le visualizzazioni coinvolte nel join.

Per farlo, aggiungi il parametro primary_key alla definizione del campo di chiave primaria in ogni vista:

dimension: id {
  type: number
  primary_key: yes
}

Nota: per gestire correttamente le misure unite, Looker si basa sulla specifica di una chiave primaria in cui i valori sono completamente univoci, non NULL. Se i tuoi dati non contengono una chiave primaria, valuta se la concatenazione di più campi comporterebbe una chiave primaria di valori completamente univoci e non NULL. Se la chiave primaria non è univoca o contiene valori NULL e la tua query include dati che rivelano questi problemi, Looker restituisce un errore come descritto nella pagina Errore: valore non univoco/chiave primaria (o sql_distinct_key), overflow o collisione di valori durante il calcolo della somma.

Dialetti SQL supportati

Affinché Looker supporti i dati aggregati simmetrici nel tuo progetto Looker, deve essere supportato anche dal dialetto del tuo database. La tabella seguente mostra quali dialetti supportano i dati aggregati simmetrici nell'ultima release di Looker:

Dialetto	Supportato?
Valanga atiana	Sì
Amazon Athena	Sì
Amazon Aurora MySQL	Sì
Amazon Redshift	Sì
Apache drud	No
Apache Druid 0.13 e versioni successive	No
Apache Druid 0.18 e versioni successive	No
Apache Hive 2.3 e versioni successive	No
Apache Hive 3.1.2 o versioni successive	No
Apache Spark 3 e versioni successive	Sì
ClickHouse	No
Cloudera Impala 3.1 o versioni successive	Sì
Cloudera Impala 3.1+ con driver nativo	Sì
Cloudera Impala con driver nativo	No
DataVirtuality	Sì
Databricks	Sì
Denodo 7	Sì
Denodo 8	Sì
Dremio	No
Dremio 11+	Sì
Exasol	Sì
Firebolt	Sì
SQL precedente di Google BigQuery	Sì
SQL standard di Google BigQuery	Sì
Google Cloud PostgreSQL	Sì
Google Cloud SQL	Sì
Google Spanner	Sì
Verde prugna	Sì
HyperSQL	No
IBM Netezza	Sì
MariaDB	Sì
Microsoft Azure PostgreSQL	Sì
Database SQL di Microsoft Azure	Sì
Analisi di Microsoft Azure Synapse	Sì
Microsoft SQL Server 2008 e versioni successive	Sì
Microsoft SQL Server 2012 e versioni successive	Sì
Microsoft SQL Server 2016	Sì
Microsoft SQL Server 2017 e versioni successive	Sì
MongoBI	No
MySQL	Sì
MySQL 8.0.12 o versioni successive	Sì
Oracle	Sì
ADWC Oracle	Sì
PostgreSQL 9.5 e versioni successive	Sì
PostgreSQL pre-9.5	Sì
PrestoDB	Sì
PrestoSQL	Sì
SAP HANA 2 o versioni successive	Sì
SingleStore	Sì
SingleStore 7 o versioni successive	Sì
Snowflake	Sì
Teradata	Sì
Trino	Sì
Vettore	Sì
Vertica	Sì

Se il tuo dialetto non supporta le aggregazioni simmetriche, fai attenzione quando esegui i join in Looker, poiché alcuni tipi di join possono generare aggregazioni imprecise (come somme e medie). Questo problema e le relative soluzioni sono descritti in dettaglio nel post della scheda Community Il problema dei fanout SQL.

Scopri di più sulle unioni

Per scoprire di più sui parametri di join in LookML, consulta la documentazione relativa ai riferimenti di join.