En esta página, se describen los patrones más comunes en LookML.
Cómo etiquetar campos (y nombres en la IU)
Looker convierte los nombres de campo de LookML en las strings que se muestran en la IU combinando el nombre de la vista en una fuente de grosor normal con el nombre corto del campo en negrita. Por ejemplo, un campo llamado Importe en la vista Pedidos aparecerá en la IU como Importe de los pedidos. En esta página, aparecen en negrita y el nombre de la vista está en mayúsculas (ORDERS Amount) para que el debate sea más claro.
Si quieres que un campo tenga un nombre diferente del nombre de su columna en una tabla, simplemente cambia el nombre del campo y declara su vinculación de sql:. En el siguiente ejemplo, hay una tabla airports con una columna cntrl_twr. Looker generaría 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
}
}
Cómo filtrar recuentos por dimensión
Es bastante fácil agrupar por dimensión y contar entidades. Agruparlas por País de los USUARIOS, Recuento de PEDIDOS te dirá de dónde provienen tus pedidos por país. Sin embargo, suele ser útil crear un recuento filtrado por algún valor dimensional. Por ejemplo, podrías realizar una nueva medida 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 usar 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 encerrarla 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 ese Y”. En LookML, el patrón de diseño consiste en 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"
}
Para calcular los porcentajes, usa el formulario que aparece a continuación. 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, lo que 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 cero en nulo, lo que hará que el resultado sea nulo y evitará un error.
100.0 * ${returned_count} / NULLIF(${count}, 0)
Cómo usar conjuntos para los detalles desglosados
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 medición en la IU de Looker, se crea una consulta nueva que localiza el conjunto de datos que conforman la medición. Cada valor de cada dimensión de la fila de la tabla se agrega a los filtros actuales.
Para mostrar los detalles, Looker necesita una lista específica de campos de desglose para mostrar cuando se hace clic en el valor de la medición. Cuando generas un modelo, el generador suele crear algunos campos iniciales de desglose por ti. Además, puedes agregar campos de desglose por tu cuenta. Por ejemplo, supongamos que estamos midiendo ORDERS Count por USERS State durante la última semana. En Looker, la consulta se vería de la siguiente manera:
| Estado de USERS | Recuento de ORDERS |
|---|---|
| California | 24 |
| Texas | 5 |
| Colorado | 4 |
| Florida | 4 |
| Illinois | 4 |
Si hacemos clic en 24 en la fila California, el comportamiento esperado es que veríamos los 24 pedidos provenientes de California.
Looker se encarga de agregar el filtro USUARIOS Estado: California, pero Looker no sabe qué campos quieres mostrar en el pedido. Deberás usar un conjunto para declarar esos campos en tu modelo.
En LookML, un conjunto es una lista de nombres de campos (dimensión, medida y filtro). Los conjuntos se usan para indicarle a Looker qué campos tienen las siguientes características:
- Deseas mostrar cuando desglosas un recuento o alguna otra medición
- Cómo importar cuando te unes a una vista
- Se indexan en una exploración.
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 mediante la declaración del conjunto como un array. Puedes declarar conjuntos literales con '[]'.
En este ejemplo:
view: customers {
dimension: id {
primary_key: yes
}
measure: count {
type: count
}
dimension: city {}
dimension: state {}
dimension: name {}
}
Los campos que queremos mostrar son id, name y city.
En la medición, simplemente podríamos declarar un array literal.
measure: count {
type: count
drill_fields: [id, name, city]
}
En el caso de 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: CUSTOMERS Count y CUSTOMERS In California Count. Cuando desglosamos cualquiera de estos recuentos, nos gustaría mostrar los campos id, name y city. Si declaramos los campos literalmente, podríamos:
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 cambio, LookML proporciona una forma de crear conjuntos con nombre que podemos mantener en un solo lugar y usar en varios.
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 conjuntos es aditiva: si declaras un conjunto en varios lugares, Looker incluirá todos los campos que se declararon para el conjunto en todas las ubicaciones.
- Puedes incorporar conjuntos de otros conjuntos; para ello, escribe el nombre del otro 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.
Leer la referencia de los conjuntos completos
Cómo personalizar las visualizaciones de desglose
Si el administrador de Looker habilitó la función Labs de Perforación visual, las visualizaciones de desglose de la función Mirar y explorar no siempre se establecerán de forma predeterminada en una tabla de datos. En este caso, puedes personalizar la visualización que se muestra usando variables líquidas en el parámetro link, como se muestra en la página de documentación del parámetro link y en la página de prácticas recomendadas sobre el desglose de datos más eficiente.
Los paneles admiten el desglose visual mediante el parámetro link sin la necesidad de habilitar la función Dilling visual Labs.
Filtrado de conjuntos de resultados
LookML proporciona un conjunto de operaciones de filtro que se pueden aplicar a campos y exploraciones para filtrar 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 en una exploración. Los filtros aparecerán en la IU de Looker y, aunque los usuarios pueden cambiar el valor de filtro predeterminado que proporcionas, no pueden quitarlos. Por lo general, estos filtros se usan para quitar datos que normalmente no deseas incluir. Por ejemplo, supongamos que en la exploración de 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 quería ver los pedidos con otros valores de estado, podía establecer ORDERS Status como % en la IU.
sql_always_where en Explorar
Si deseas aplicar una restricción de búsqueda que los usuarios no pueden modificar, puedes usar sql_always_where. Además de las consultas que ejecutan usuarios humanos, la restricción se aplicará a los paneles, las vistas programadas y la información incorporada que se base en esa exploración. No se muestra una condición sql_always_where al usuario, a menos que mire el SQL subyacente de cualquier consulta que cree.
El siguiente ejemplo evita que los usuarios consulten pedidos anteriores al 01-01-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 un poco de atención a la hora de realizar consultas, ya que las consultas ilimitadas pueden volverse demasiado pesadas en la base de datos. LookML proporciona una forma de abordar esto en la forma de conditionally_filter.
Usa el parámetro conditionally_filter para aplicar un filtro a la consulta, a menos que el usuario ya haya agregado un filtro en 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]
}