En esta página, se describen patrones más comunes de LookML.
Etiqueta campos (y nombres en la IU)
Looker convierte los nombres de los campos de LookML en las strings que se muestran en la IU, ya que combina el nombre de la vista en una fuente normal con el nombre corto del campo en negrita. Por ejemplo, un campo llamado Amount en la vista Orders aparecerá en la IU como Orders Amount. En esta página, aparecen en negrita y el nombre de la vista en mayúsculas (ORDERS Amount) para que la conversación sea más clara.
Si deseas que el nombre de un campo sea diferente al nombre de columna en una tabla, simplemente cambia el nombre del campo y declara su vinculación sql:. En el siguiente ejemplo, hay una tabla airports con una columna cntrl_twr. Looker generará la siguiente declaración:
view: airports {
dimension: cntrl_twr { # full name: airports.cntrl_twr
type: yesno # default name: AIRPORT Cntrl Twr (Yes/No)
sql: ${TABLE}.cntrl_twr ;; # the sql expression for this field
}
}
Cambiaremos el nombre de la dimensión cntrl_twr para que sea legible.
view: airports {
dimension: has_control_tower { # full name: airports.has_control_tower
type: yesno # aliased name: AIRPORTS Has Control Tower (Yes/No)
sql: ${TABLE}.cntrl_twr ;; # the sql expression for this field
}
}
Filtrar recuentos por dimensión
Es muy fácil agrupar según una dimensión y contar entidades; si agrupas por USERS Country, ORDERS Count te indicará de dónde provienen tus pedidos. Sin embargo, suele ser útil crear un recuento filtrado por un valor dimensional. Por ejemplo, podría hacer una medida nueva ORDERS France Count:
view: users {
dimension: country {}
}
view: orders {
dimension: id {
primary_key: yes
sql: ${TABLE}.id ;;
}
measure: count {
type: count
drill_fields: [detail]
}
measure: france_count {
type: count # COUNT(CASE WHEN users.country = 'France' THEN 1 ELSE NULL END)
filters: [users.country: "France"]
}
}
Los filtros pueden usar cualquier expresión. Si quisieras un campo que contara usuarios de la UE, podrías usar algo como lo siguiente:
measure: eu_count {
type: count # COUNT(CASE WHEN users.countrycode IN 'UK','FR','ES' THEN 1 ELSE NULL END)
drill_fields: [detail]
filters: [users.countrycode: "UK,FR,ES"]
}
Si deseas filtrar con una expresión matemática, asegúrate de encerrarlo entre comillas dobles:
measure: total_orders_above_100_dollars {
type: sum # SUM(CASE WHEN order.value > 100 THEN order.value ELSE NULL END)
sql: ${order.value} ;;
drill_fields: [detail]
filters: [order.value: ">100"]
}
Porcentajes
Muchos indicadores clave de rendimiento se expresan en forma de porcentajes, como el porcentaje de artículos devueltos, el porcentaje de correos electrónicos que generaron una venta u otras instancias del porcentaje de X que Y. En LookML, el patrón de diseño es crear recuentos para las dos condiciones y crear un tercer campo que calcule el porcentaje entre las dos.
dimension: returned {
type: yesno
}
measure: count { # total count of items
type: count_distinct
sql: ${TABLE}.id ;;
drill_fields: [detail]
}
measure: returned_count { # count of returned items
type: count_distinct
sql: ${TABLE}.id ;;
drill_fields: [detail]
filters: [returned: "Yes"]
}
measure: percent_returned {
type: number
sql: 100.0 * ${returned_count} / NULLIF(${count}, 0) ;;
value_format: "0.00"
}
Usa el siguiente formulario para calcular porcentajes. En Postgres, los recuentos son números enteros, y la división entre números enteros da como resultado números enteros. La multiplicación por 100.0 convierte el primer recuento en un número de punto flotante y, por lo tanto, convierte el resto de la expresión en un número de punto flotante. Para evitar errores de división por cero, NULLIF(value, 0) convertirá un valor en cero en nulo, lo que hará que el resultado sea nulo y evite un error.
100.0 * ${returned_count} / NULLIF(${count}, 0)
Usa conjuntos para los detalles de desglose
Una de las funciones más potentes de Looker es la capacidad de desglosar los datos para ver las entidades subyacentes que conforman un recuento o alguna otra medida.
Cuando se hace clic en una medida en la IU de Looker, se crea una consulta nueva que localiza el conjunto de datos que conforman la medida. Cada valor de cada dimensión de la fila de la tabla se agrega a los filtros actuales.
A fin de mostrar los detalles, Looker necesita una lista específica de campos de entrenamiento para mostrar cuando se haga clic en el valor de la medida. Cuando generas un modelo, el generador suele crear algunos campos de perforación iniciales. Además, puede agregar campos de prueba usted mismo. Por ejemplo, supongamos que estamos midiendo Recuento de pedidos por Estado de USERS durante la última semana. En Looker, la consulta se vería de la siguiente manera:
| Estado de USERS | Recuento de pedidos: ORDERS |
|---|---|
| California | 24 |
| Texas | 5 |
| Colorado | 4 |
| Florida | 4 |
| Illinois | 4 |
Si hacemos clic en 24 en la fila California, el comportamiento esperado sería que viéramos los 24 pedidos procedentes de California.
Looker se encarga de agregar el filtro USERS State: California, pero Looker no sabe qué campos desea mostrar en el orden. Deberás usar un conjunto para declarar esos campos en tu modelo.
En LookML, un conjunto es una lista de nombres de campos (dimensiones, medidas y filtros). Los conjuntos se usan para indicarle a Looker qué campos:
- Cuando quieres desglosar un recuento o alguna otra medida
- Para importar contenido al unirte a una vista
- Se indexan en Explorar
El mismo conjunto se puede usar en muchos lugares de un modelo, por lo que Looker proporciona varias formas de crear conjuntos.
Conjuntos literales
La forma más simple de un conjunto es un conjunto literal. Un conjunto literal se crea simplemente declarando el conjunto como un arreglo. Puedes declarar conjuntos literales con '[]'.
Dado este ejemplo:
view: customers {
dimension: id {
primary_key: yes
}
measure: count {
type: count
}
dimension: city {}
dimension: state {}
dimension: name {}
}
Los campos que nos gustaría mostrar son id, name y city.
En la medida, simplemente podemos declarar un arreglo literal.
measure: count {
type: count
drill_fields: [id, name, city]
}
Para los conjuntos que solo se usan una vez, declararlos literalmente es simple y fácil de entender.
Conjuntos con nombre
Supongamos que tenemos dos recuentos: Conteo de CLIENTES y Conteo de clientes en California. Al desglosar cualquiera de estos recuentos, nos gustaría mostrar los campos id, name y city. Si declaramos los campos literalmente, podríamos hacer lo siguiente:
view: customers {
measure: count {
type: count
drill_fields: [id, name, city]
}
measure: in_california_count {
type: count
filters: [state: "California"]
}
}
Si quisiéramos agregar un campo nuevo (por ejemplo, el campo customers.state), tendríamos que editar ambas listas. En su lugar, LookML proporciona una forma de crear conjuntos con nombre que podemos mantener en un solo lugar y usar en varios lugares.
El siguiente código crea un conjunto customers.detail y apunta ambos recuentos al mismo conjunto de campos.
view: customers {
set: detail {
fields: [id, name, city] # creates named set customers.detail
}
measure: count {
type: count
drill_fields: [detail*] # show fields in the set "customers.detail"
}
measure: in_california_count {
type: count
filters: [state: "California"]
}
}
Los conjuntos de LookML son bastante potentes:
- La redeclaración de los conjuntos es aditiva; si declara un conjunto en varios lugares, Looker incluye todos los campos que se declararon para el conjunto en todas las ubicaciones.
- Puedes incorporar conjuntos en otros conjuntos si escribes el otro nombre de conjunto seguido de un asterisco, como
setname*. - Incluso puedes quitar elementos de los conjuntos si colocas un guion antes del nombre del campo, como
-fieldname.
Lee la referencia completa de conjuntos
Personaliza visualizaciones de taladro
Si el administrador de Looker habilitó la función de labs de perforación visual, las visualizaciones de los simulados no siempre se establecerán de forma predeterminada en una tabla de datos. En este caso, puedes personalizar la visualización que se muestra con las variables líquidas en el parámetro link, como se muestra en la página de documentación del parámetro link y en el artículo Exploración de datos más potente.
La nueva experiencia del panel admite la perforación visual con el parámetro link sin necesidad de habilitar la función de Labs de perforación visual.
Filtra conjuntos de resultados
LookML proporciona un conjunto de operaciones de filtro que se pueden aplicar a los campos y explora para filtrar los conjuntos de resultados antes de que se muestren al usuario.
always_filter en Explorar
Usa always_filter para aplicar siempre un conjunto de filtros a cualquier consulta que se ejecute dentro de Explorar. Los filtros aparecerán en la IU de Looker y, aunque los usuarios puedan cambiar el valor de filtro predeterminado que usted proporcione, no podrán quitarlos. En general, estos filtros se usan para quitar los datos que normalmente no deseas incluir. Por ejemplo, supongamos que en la pestaña Pedidos, solo queríamos ver los pedidos que estaban completos o pendientes. Podríamos agregar lo siguiente:
explore: orders {
view_name: order
filters: [status: "complete,pending"]
}
}
Si el usuario desea ver pedidos con otros valores de estado, puede configurar el Estado de ORDERS en % en la IU.
sql_always_where en Explorar
Si deseas aplicar una restricción de consulta que los usuarios no pueden cambiar, puedes usar sql_always_where. Además de las consultas que ejecuten los usuarios, la restricción se aplicará a los paneles, las apariencias programadas y la información incorporada que dependa de esa exploración. Una condición sql_always_where no se muestra al usuario, a menos que mire el SQL subyacente de las consultas que crea.
El siguiente ejemplo impide que los usuarios vean pedidos antes del 1 de enero de 2012:
# Using Looker references
explore: order {
sql_always_where: ${created_date} >= '2012-01-01' ;;
}
# Using raw SQL
explore: order {
sql_always_where: DATE(created_time) >= '2012-01-01' ;;
}
conditionally_filter en Explorar
Las tablas muy grandes requieren cierta reflexión cuando se realizan consultas, ya que las consultas ilimitadas pueden volverse demasiado pesadas en la base de datos. LookML proporciona una forma de abordar esto en forma de conditionally_filter.
Usas el parámetro conditionally_filter para aplicar un filtro a la consulta, a menos que el usuario ya haya agregado un filtro para uno de los campos enumerados en la sección unless.
En el siguiente ejemplo, no se realizará ningún cambio en la consulta del usuario si este aplicó un filtro en uno o más de estos campos: created_date, shipped_time, shipped_date, orders.id o customer.name. Si el usuario no filtró ninguno de esos campos, Looker agregará automáticamente un filtro de 1 día el orders.created_time.
filters: [orders.created_time: "1 day"]
unless: [created_date, shipped_time, shipped_date, orders.id, customer.name]
}