Cada archivo de vista de tu proyecto de LookML define una sola vista en Looker, que especifica una tabla para consultar y qué campos (dimensiones y medidas) de esa tabla se mostrarán en la IU de Looker. Una vista corresponde a una sola tabla en tu base de datos o a una sola tabla derivada.
En esta guía, obtendrás información sobre los siguientes temas:
- Cómo se relacionan los elementos de un archivo de vista de LookML con SQL
- Cómo crear dimensiones nuevas con SQL sin procesar, la lógica de casos de LookML integrada o la lógica integrada de LookML de contenedores
Para obtener más información sobre el uso de SQL para definir y personalizar tablas derivadas en LookML, consulta Conceptos de SQL para tablas derivadas.
La vista
Este es un ejemplo de un archivo de vista llamado users.view
, que incluye definiciones para la tabla de la base de datos que se consultará junto con varias dimensiones y medidas:
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
}
}
El primer elemento de la definición de la vista es el parámetro sql_table_name
, que especifica la tabla de tu base de datos que consultará una vista. Este valor es el único lugar en todo el modelo en el que se define el nombre de la tabla, porque todas las demás referencias a la vista usarán el alias de la tabla ${TABLE}
. Si deseas cambiar el nombre de la tabla de la base de datos, solo debes hacerlo en el parámetro sql_table_name
. Hay algunos aspectos que debes tener en cuenta cuando haces referencia a una tabla de base de datos.
Looker usa el valor sql_table_name
para escribir su cláusula FROM de SQL, seguida del nombre de la vista, que se convierte en el alias de la tabla. El equivalente de SQL se vería de la siguiente manera:
FROM `thelook`.`users` AS `users`
Looker usa las dimensiones y medidas definidas de la vista para generar su cláusula SELECT de SQL. Cada dimensión define el tipo de dimensión, como cadena, número o booleano, y un parámetro sql
de LookML que hace referencia a la dimensión dentro de la vista con el alias de la tabla. Para una dimensión llamada age
, consulta el siguiente ejemplo:
dimension: age {
type: number
sql: ${TABLE}.age ;;
}
Cuando Looker crea la sentencia SQL para enviarla a tu base de datos, sustituye el alias de la vista en ${TABLE}
. Para la dimensión age
del ejemplo anterior, Looker produciría una cláusula SELECT como la siguiente:
SELECT `users`.`age` AS `users.age`
Las mediciones suelen ser agregaciones que se realizan en dimensiones. Especificas el alias de la dimensión en la expresión sql
de una medida. Por ejemplo, una medida que calcula el promedio de la dimensión age
puede tener una expresión sql
con el alias ${age}
, como en el siguiente ejemplo:
dimension: age {
type: number
sql: ${TABLE}.age ;;
}
measure: average_age {
type: average
sql: ${age} ;;
}
Si cambias el nombre de la dimensión age
, su alias nuevo se propagará a cualquiera de sus referencias de alias de dimensión.
Cómo personalizar un archivo de vista
Puedes personalizar las expresiones de SQL de tu archivo de vista o usar la lógica de LookML integrada de Looker para imitar la lógica de una expresión de SQL.
Usa una expresión de SQL
Supongamos que quieres dividir los datos etarios en cuatro cohortes: los usuarios menores de 18 años se definen como "jóvenes", los usuarios de 18 a 35 años como "adultos jóvenes", los usuarios de entre 36 y 65 años como "adultos mayores" y los usuarios de 65 años o más como "adultos mayores". Para realizar esta división, debes definir una dimensión nueva, por ejemplo, dimension: age_cohort
, con una expresión sql
que capture estas cohortes. La siguiente definición de dimensión de LookML usa una sentencia CASE adecuada para una conexión de base de datos de 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 ;;
}
Ahora que definiste tu cohorte por edad como una dimensión, puedes volver a usar la lógica CASE si incluyes la dimensión de cohorte por edad en tus consultas de Explorar.
Cuando creas una consulta de exploración con la dimensión de cohorte de edad, puedes usar la pestaña de SQL de Explorar para ver el SQL que genera Looker. Con la dimensión de cohorte de edad, SQL se verá así:
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
Usa la lógica de casos integrados de Looker
Puedes lograr el mismo efecto que una instrucción CASE en SQL con una expresión independiente de la base de datos. El parámetro case
de LookML te permite definir los buckets de cohortes que se componen de instrucciones when
que usan expresiones sql
para capturar condiciones y cadenas específicas para etiquetar los resultados.
El siguiente es un ejemplo de la misma dimensión age_cohort
nueva que se escribe con el parámetro case
de LookML:
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"
}
}
Durante el tiempo de ejecución, Looker compila la sintaxis correcta de CASE de SQL para tu base de datos. Además, Looker crea otra expresión para controlar el orden de los grupos, de modo que las etiquetas resultantes no solo se ordenen de forma alfanumérica (a menos que definas el orden de clasificación como alfanumérico). Looker compila una consulta en SQL resultante que se parece a la siguiente:
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
Usa la lógica de niveles o contenedores integrados de Looker
Otro método para especificar cómo se deben agrupar los valores numéricos usa los tipos de parámetros bin
o tier
integrados de Looker. type:bin
se usa junto con el parámetro bins
. Del mismo modo, type: tier
se usa con el parámetro tiers
para separar una dimensión numérica en un conjunto de rangos de números. La desventaja es que no puedes definir etiquetas para cada intervalo.
En el siguiente ejemplo de LookML, se usa el parámetro bins
en una dimensión para definir el valor mínimo en cada conjunto:
dimension: age_cohort {
type: bin
bins: [18,36,65]
style: integer
sql: ${age} ;;
}
Puedes usar el parámetro tiers
en una dimensión de la misma manera. Por ejemplo:
dimension: age_cohort {
type: tier
tiers: [18,36,65]
style: integer
sql: ${age} ;;
}
Luego, Looker genera algo como la siguiente sentencia SQL:
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
Recursos relacionados
- Conceptos de SQL para uniones
- Conceptos de SQL para tablas derivadas
- Usa el generador de SQL de Looker
- Cómo Looker genera SQL
- Guía de soluciones de Looker: Maximizing code reusability with DRY LookML