Utilizzare i join in LookML

I join ti consentono di collegare visualizzazioni diverse in modo da poter esplorare i dati di più visualizzazioni contemporaneamente e vedere in che modo 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 spiega i join in LookML, inclusi i parametri di join specifici e i pattern di join.

I join iniziano con un'esplorazione

I join vengono definiti nel file del modello per stabilire la relazione tra un'esplorazione e una visualizzazione. I join collegano una o più visualizzazioni a una singola esplorazione, direttamente o tramite un'altra visualizzazione unita.

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

explore: order_items { ... }

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

SELECT ...
FROM order_items

Puoi unire informazioni aggiuntive all'esplorazione order_items. Ad esempio, puoi utilizzare il seguente codice LookML di esempio per unire la visualizzazione 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 codice LookML mostrato in precedenza esegue due operazioni. Innanzitutto, puoi visualizzare i campi di orders e order_items nel selettore campi Esplora:

In secondo luogo, il codice LookML descrive come unire orders e order_items. Questo codice 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 modo più dettagliato nelle sezioni seguenti.

Suggerimento del team di chat: gli utenti chiedono informazioni soprattutto sull'errore di convalida "Campo sconosciuto o inaccessibile", che può essere causato da un join mancante. Per ulteriori informazioni, consulta la pagina Errore: campo sconosciuto o inaccessibile.

Parametri di join

Per eseguire i join vengono utilizzati quattro parametri principali: join, type, relationship e sql_on.

Passaggio 1: avviare l'esplorazione

Innanzitutto, crea l'esplorazione order_items:

explore: order_items { ... }

Passaggio 2: join

Per unire una tabella, devi prima dichiararla in una visualizzazione. In questo esempio, supponiamo che orders sia una visualizzazione esistente nel modello.

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

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

Passaggio 3: type

Valuta il tipo di join da eseguire. Looker supporta LEFT JOIN, INNER JOIN, FULL OUTER JOIN e CROSS JOIN. Questi corrispondono ai valori del 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 join tra l'esplorazione order_items e la visualizzazione orders. Dichiarare correttamente la relazione di un join è importante per consentire a Looker di calcolare le misure accurate. La relazione è definita dall'esplorazione order_items alla visualizzazione orders. Le opzioni possibili sono one_to_one, many_to_one, one_to_many e many_to_many.

In questo esempio, possono essere presenti molti articoli dell'ordine per un singolo ordine. La relazione dall'esplorazione order_items alla 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, Looker utilizza per impostazione predefinita many_to_one.

Per altri suggerimenti su come definire correttamente il parametro relationship per un join, consulta la sezione Definire correttamente il parametro relationship.

Passaggio 5: sql_on

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

Suggerimento:in genere consigliamo di utilizzare il parametro foreign_key perché può fare tutto ciò che può fare il parametro, ma in genere è più facile da comprendere.

sql_onsql_on

Il parametro sql_on è equivalente alla clausola ON nell'SQL generato per una query. Con questo parametro, puoi dichiarare quali campi devono essere abbinati per eseguire il join:

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 gli 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 visualizzare i campi di order_items e orders.

Per saperne di più su come testare le modifiche LookML in un'esplorazione, consulta la sezione Testare i campi nell'esplorazione.

Unire tramite un'altra visualizzazione

Puoi unire una visualizzazione a un'esplorazione tramite un'altra visualizzazione. Nell'esempio dei parametri di join, hai unito orders a order_items utilizzando il campo order_id. Potremmo anche voler unire i dati di una visualizzazione denominata users all'esplorazione order_items, anche se non condividono un campo comune. Questa operazione può essere eseguita unendo tramite la visualizzazione orders.

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

Ecco un esempio che utilizza 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} ;;
  }
}

Unire una visualizzazione più di una volta

Una visualizzazione users contiene i dati sia per gli acquirenti sia 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, assegnando al join 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, vengono uniti solo i dati degli acquirenti come buyers, mentre vengono uniti solo i dati dei venditori come sellers.

Nota: nella join, ora è necessario fare riferimento alla visualizzazione users con i nomi alias buyers e sellers.

Limitare i campi di un join

Il parametro fields ti consente di specificare i campi che vengono importati da un join in un'esplorazione. Per impostazione predefinita, tutti i campi di una visualizzazione vengono importati quando vengono uniti. Tuttavia, potresti voler importare solo un sottoinsieme di campi.

Ad esempio, quando orders viene unito a order_items, potresti voler importare 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 è definito all'interno di una visualizzazione utilizzando il set parametro. Supponiamo di avere il seguente insieme definito nella visualizzazione orders:

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

Puoi scegliere di importare 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*]
  }
}

Aggregati simmetrici

Looker utilizza una funzionalità denominata "aggregati simmetrici" per calcolare correttamente le aggregazioni (come somme e medie), anche quando i join generano un fanout. Gli aggregati simmetrici sono descritti in modo più dettagliato nella sezione Informazioni sugli aggregati simmetrici. Il problema di fanout che gli aggregati simmetrici risolvono è spiegato nel post per la community Il problema dei fanout SQL.

Chiavi primarie obbligatorie

Per importare le misure (aggregazioni) tramite i join, devi definire le chiavi primarie in tutte le visualizzazioni coinvolte nel join.

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

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 e non NULL. Se i dati non contengono una chiave primaria, valuta se la concatenazione di più campi genererebbe una chiave primaria di valori completamente univoci e non NULL. 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 nella pagina delle best practice Errore: valore/chiave primaria non univoco (o sql_distinct_key), overflow o collisione di valori durante il calcolo della somma.

Dialetti SQL supportati

Affinché Looker supporti gli aggregati simmetrici nel tuo progetto Looker, anche il dialetto del database deve supportarli. La tabella seguente mostra quali dialetti supportano gli aggregati simmetrici nell'ultima release di Looker:

Dialetto	Supportata?
Actian Avalanche
Amazon Athena
Amazon Aurora MySQL
Amazon Redshift
Amazon Redshift 2.1+
Amazon Redshift Serverless 2.1+
Apache Druid
Apache Druid 0.13.x - 0.17.x
Apache Druid 0.18+
Apache Hive 2.3+
Apache Hive 3.1.2+
Apache Spark 3+
ClickHouse
Cloudera Impala 3.1+
Cloudera Impala 3.1+ with Native Driver
Cloudera Impala with Native Driver
DataVirtuality
Databricks
Denodo 7
Denodo 8 & 9
Dremio
Dremio 11+
Exasol
Google BigQuery Legacy SQL
Google BigQuery Standard SQL
Google Cloud AlloyDB for PostgreSQL
Google Cloud PostgreSQL
Google Cloud SQL
Google Spanner
Greenplum
HyperSQL
IBM Netezza
MariaDB
Microsoft Azure PostgreSQL
Microsoft Azure SQL Database
Microsoft Azure Synapse Analytics
Microsoft SQL Server 2008+
Microsoft SQL Server 2012+
Microsoft SQL Server 2016
Microsoft SQL Server 2017+
MongoBI
MySQL
MySQL 8.0.12+
Oracle
Oracle ADWC
PostgreSQL 9.5+
PostgreSQL pre-9.5
PrestoDB
PrestoSQL
SAP HANA
SAP HANA 2+
SingleStore
SingleStore 7+
Snowflake
Teradata
Trino
Vector
Vertica

Se il dialetto non supporta gli aggregati simmetrici, 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 alternative sono descritti in dettaglio nel post per la community Il problema dei fanout SQL.

Scopri di più sui join

Per saperne di più sui parametri di join in LookML, consulta la documentazione di riferimento sui join.