Concetti SQL per le viste

Ogni file di vista nel progetto LookML definisce una singola vista in Looker, che specifica una tabella su cui eseguire query e i campi (dimensioni e misure) di quella tabella da visualizzare nell'interfaccia utente di Looker. Una vista corrisponde a una singola tabella del database o a una singola tabella derivata.

Questa guida illustra i seguenti argomenti:

Per scoprire di più sull'utilizzo di SQL per definire e personalizzare le tabelle derivate in LookML mediante SQL, consulta Concetti SQL per le tabelle derivate.

La visualizzazione

Ecco un esempio di file di visualizzazione denominato users.view, che include le definizioni della tabella di database su cui verrà eseguita la query, oltre a diverse dimensioni e misure:

view: users {
  sql_table_name: thelook.users ;;

  dimension: id {
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }

  dimension: age {
    type: number
    sql: ${TABLE}.age ;;
  }
   measure: average_age {
    type: average
    sql: ${age} ;;  }

  dimension_group: created {
    type: time
    timeframes: [raw, time, date, week, month, quarter, year]
    sql: ${TABLE}.created_at ;;
  }

  measure: count {
    type: count
  }
}

Il primo elemento della definizione della vista è il parametro sql_table_name, che specifica la tabella del database su cui verrà eseguita una query da una vista. Questo valore è l'unico posto nell'intero modello in cui è definito il nome della tabella, perché tutti gli altri riferimenti alla vista utilizzeranno l'alias di tabella ${TABLE}. Se vuoi modificare il nome della tabella del database, devi farlo solo nel parametro sql_table_name. Quando fai riferimento a una tabella di database, ci sono alcune considerazioni da fare.

Looker utilizza il valore sql_table_name per scrivere la clausola FROM SQL, seguita dal nome della visualizzazione, che diventa l'alias della tabella. L'equivalente SQL sarebbe simile a questo:

FROM `thelook`.`users` AS `users`

Looker utilizza le dimensioni e le misure definite dalla vista per generare la clausola SQL SELECT. Ogni dimensione definisce il tipo di dimensione, ad esempio stringa, numero o booleano, e un parametro LookML sql che fa riferimento alla dimensione nella vista, utilizzando l'alias della tabella. Per una dimensione denominata age, vedi il seguente esempio:

  dimension: age {
    type: number
    sql: ${TABLE}.age ;;
  }

Quando Looker crea il codice SQL da inviare al database, sostituisce l'alias della vista in ${TABLE}. Per la dimensione age dell'esempio precedente, Looker produrrà una clausola SELECT come la seguente:

SELECT `users`.`age` AS `users.age`

Le misure sono spesso aggregazioni eseguite sulle dimensioni. L'alias della dimensione viene specificato nell'espressione sql di una misura. Ad esempio, una misura che calcola la media della dimensione age può avere un'espressione sql contenente l'alias ${age}, come nell'esempio seguente:

  dimension: age {
    type: number
    sql: ${TABLE}.age ;;
  }

  measure: average_age {
    type: average
    sql: ${age} ;;
  }

Se rinomini la dimensione age, il nuovo alias si propaga a qualsiasi riferimento all'alias di dimensione.

Personalizzazione di un file di visualizzazione

Puoi personalizzare le espressioni SQL del file della vista o utilizzare la logica LookML integrata di Looker per imitare la logica di un'espressione SQL.

Utilizzo di un'espressione SQL

Supponiamo che tu voglia suddividere i dati sull'età in quattro coorti, con gli utenti minori di 18 anni definiti come "Giovani", gli utenti di età compresa tra 18 e 35 anni come "Giovani adulti", gli utenti di età compresa tra 36 e 65 anni come "Adulti di mezza età" e gli utenti di età pari o superiore a 65 anni come "Anziani". Per eseguire questa suddivisione, devi definire una nuova dimensione, ad esempio dimension: age_cohort, con un'espressione sql che acquisisca queste coorti. La seguente definizione di dimensione LookML utilizza un'istruzione CASE appropriata per una connessione al database MySQL:

dimension: age_cohort {
  type: string
  sql:
    CASE
      WHEN ${age} < 18 THEN 'Youth'
      WHEN ${age} < 35 THEN 'Young Adult'
      WHEN ${age} < 65 THEN 'Older Adult'
      ELSE 'Senior'
    END ;;
}

Ora che hai definito la coorte di età come dimensione, puoi riutilizzare la logica CASE includendo la dimensione della coorte di età nelle query di esplorazione.

Quando crei una query di esplorazione con la dimensione Coorte di età, puoi utilizzare la scheda SQL dell'esplorazione per visualizzare il codice SQL generato da Looker. Con la dimensione della coorte di età, l'SQL avrà un aspetto simile al seguente:

SELECT
CASE
  WHEN users.age < 18 THEN 'Youth'
  WHEN users.age < 35 THEN 'Young Adult'
  WHEN users.age < 65 THEN 'Older Adult'
  ELSE 'Senior'
END  AS `users.age_cohort`,
AVG(`age`) AS `users.average_age`,
COUNT(*) AS `users.count`
FROM
  `thelook`.`users` AS `users`
GROUP BY
  1
ORDER BY
  2 DESC
LIMIT 500

Utilizzo della logica integrata delle richieste di Looker

Puoi ottenere lo stesso effetto di un'istruzione CASE SQL con un'espressione indipendente dal database. Il parametro LookML case consente di definire i bucket di coorte composti da istruzioni when che utilizzano espressioni sql per acquisire condizioni e stringhe specifiche per etichettare i risultati.

Di seguito è riportato un esempio della stessa nuova dimensione age_cohort scritta con il parametro LookML case:

  dimension: age_cohort {
    case: {
      when: {
        sql: ${age} < 18 ;;
        label: "Youth"
      }
      when: {
        sql: ${age} < 35 ;;
        label: "Young Adult"
      }
      when: {
        sql: ${age} < 65 ;;
        label: "Middle-aged Adult"
      }
      else: "Older Adult"
    }
  }

In fase di esecuzione, Looker crea la sintassi corretta di CASE SQL per il tuo database. Inoltre, Looker crea un'altra espressione per gestire l'ordinamento dei gruppi, in modo che le etichette risultanti non vengano ordinate solo in formato alfanumerico (a meno che tu non definisci l'ordinamento in formato alfanumerico). Looker genera una query SQL risultante simile alla seguente:

SELECT
CASE
  WHEN users.age < 18  THEN '0'
  WHEN users.age < 35  THEN '1'
  WHEN users.age < 65  THEN '2'
  ELSE '3'
END AS `users.age_cohort__sort_`,
CASE
  WHEN users.age < 18  THEN 'Youth'
  WHEN users.age < 35  THEN 'Young Adult'
  WHEN users.age < 65  THEN 'Older Adult'
  ELSE 'Senior'
END AS `users.age_cohort`,
AVG(`age`) AS `users.average_age`,
COUNT(*) AS `users.count`
FROM
  `thelook`.`users` AS `users`
GROUP BY
  1,
  2
ORDER BY
  1
LIMIT 500

Utilizzo della logica bin o livello integrata di Looker

Un altro metodo per specificare il modo in cui i valori numerici devono essere raggruppati utilizza i tipi di parametri integrati bin o tier di Looker. type:bin viene utilizzato in combinazione con il parametro bins, così come type: tier viene utilizzato in combinazione con il parametro tiers, per separare una dimensione numerica in un insieme di intervalli di numeri. Il compromesso è che non puoi definire etichette per ogni intervallo.

Il seguente esempio di LookML utilizza il parametro bins in una dimensione per definire il valore minimo in ogni set:

  dimension: age_cohort {
    type: bin
    bins: [18,36,65]
    style: integer
    sql: ${age} ;;
  }

Puoi utilizzare il parametro tiers in una dimensione esattamente nello stesso modo. Ad esempio:

  dimension: age_cohort {
    type: tier
    tiers: [18,36,65]
    style: integer
    sql: ${age} ;;
  }

Looker genera quindi un'istruzione SQL simile alla seguente:

SELECT
CASE
  WHEN users.age  < 18 THEN '0'
  WHEN users.age  >= 18 AND users.age  < 36 THEN '1'
  WHEN users.age  >= 36 AND users.age  < 65 THEN '2'
  WHEN users.age  >= 65 THEN '3'
  ELSE '4'
END AS `users.age_cohort__sort_`,
CASE
  WHEN users.age  < 18 THEN 'Below 18'
  WHEN users.age  >= 18 AND users.age  < 36 THEN '18 to 35'
  WHEN users.age  >= 36 AND users.age  < 65 THEN '36 to 64'
  WHEN users.age  >= 65 THEN '65 or Above'
  ELSE 'Undefined'
END AS `users.age_cohort`,
AVG(`age`) AS `users.average_age`,
COUNT(*) AS `users.count`
FROM
  `thelook`.`users` AS `users`
GROUP BY
  1,
  2
ORDER BY
  1
LIMIT 500