Patrones comunes de LookML

En esta página, se describen los siguientes patrones comunes en LookML:

Campos de etiquetado (y nombres en la IU)

Looker convierte los nombres de los campos de LookML en las cadenas que muestra la IU combinando 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 Pedidos aparece en la IU como Importe de los pedidos. En esta página, los dos nombres de los campos están en negrita y el nombre de la vista está en mayúsculas (ORDERS Amount) para que el debate sea más claro.

Si deseas que un campo tenga un nombre diferente al de su columna en una tabla, cambia el nombre del campo y usa el parámetro sql para vincular el campo a la columna adecuada de la tabla. En el siguiente ejemplo, la tabla airports tiene 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
  }
}

Puedes cambiar 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 una dimensión

Puedes agrupar por dimensión y contar entidades. Si agrupas por País de USUARIOS, Recuento de PEDIDOS te indicará de dónde provienen tus pedidos por país. Sin embargo, a menudo es útil crear un recuento que se filtre por algún valor dimensional. Por ejemplo, puedes crear una medición nueva y nombrarla 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 crear un campo que contara a los 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" o otras instancias de "el porcentaje de X que Y". En LookML, el patrón de diseño es crear recuentos para las dos condiciones y 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 formato para calcular los porcentajes. En Postgres, los recuentos son números enteros, y la división entre números enteros genera números enteros. Multiplicar 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) convierte un valor de cero en nulo, lo que hace que el resultado sea nulo y evita un error.

100.0 * ${returned_count} / NULLIF(${count}, 0)

Usa conjuntos para desglosar los detalles

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 haces clic en una medida en la IU, Looker crea una consulta nueva para localizar el conjunto de datos que conforman la medida. Cada valor de cada dimensión de la fila de la tabla se agrega a

Para mostrar los detalles, Looker necesita una lista especificada de campos de desglose para mostrar cuando se hace clic en el valor de la medida. Cuando generas un modelo, el generador generalmente crea algunos campos de desglose iniciales por ti. Además, puedes agregar campos de desglose por tu cuenta. Por ejemplo, supongamos que mides la cantidad de PEDIDOS por ESTADO DE USUARIOS en la última semana. En Looker, la consulta se vería de la siguiente manera:

Estado de USERSCantidad de PEDIDOS
California24
Texas5
Colorado4
Florida4
Illinois4

Si haces clic en 24 en la fila California, es posible que veas los 24 pedidos que provienen de California. Aunque Looker agrega el filtro USERS State: California, no sabe qué campos deseas mostrar en el pedido. Primero, necesitará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). Usas conjuntos para darle a Looker la siguiente información:

  • Los campos que quieres mostrar al desglosar un recuento o alguna otra medición
  • Los campos que deseas importar cuando unes una vista
  • Los campos que quieres que se indexen en una exploración

Dado que el mismo conjunto se puede usar en muchos lugares de un modelo, Looker proporciona varios métodos para crear conjuntos.

Conjuntos de literales

Un conjunto literal es una forma sencilla de definir un conjunto en LookML, en particular, cuando se usa solo una vez. Para crear un conjunto literal, debes declararlo como un array. Puedes declarar conjuntos de literales con [].

Considera el siguiente ejemplo:

view: customers {
  dimension: id {
    primary_key: yes
  }
  measure: count {
    type: count
  }
  dimension: city {}
  dimension: state {}
  dimension: name {}
}

En este ejemplo, los campos que deseas mostrar son id, name y city.

En la medida, puedes declarar un array literal de la siguiente manera:

measure: count {
  type: count
  drill_fields: [id, name, city]
}

Conjuntos con nombre

Supongamos que se definen dos recuentos en la vista customers: count y in_california_count. Cuando un usuario desglosa el campo Recuento o el campo Recuento en California en una exploración, deseas mostrar los campos id, name y city.

Al principio, declarar estos campos literalmente puede parecer suficiente:

view: customers {
  measure: count {
    type: count
    drill_fields: [id, name, city]
  }
  measure: in_california_count {
    type: count
    filters: [state: "California"]
    drill_fields: [id, name, city]
  }
}

Sin embargo, si deseas agregar un campo nuevo (como customers.state), tendrías que editar ambas listas, a menos que hayas utilizado el parámetro set para crear conjuntos de nombres que puedas mantener en un solo lugar y usar en varios lugares.

El siguiente código crea un conjunto customers.detail y apunta ambos cuentas 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"]
    drill_fields: [detail*]      # show fields in the set "customers.detail"
  }
}

Los conjuntos de LookML son potentes de las siguientes maneras:

  • 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 dentro de otros conjuntos. Para ello, escribe el nombre del otro conjunto seguido de un asterisco, por ejemplo, setname*.
  • Para quitar elementos de los conjuntos, coloca un guion antes del nombre del campo, por ejemplo, -fieldname.

Personaliza las visualizaciones de desglose

Si el administrador de Looker habilitó la función de Labs de Exploración visual, las visualizaciones de desglose de Mirar y Explorar no siempre serán una tabla de datos de forma predeterminada. En este caso, puedes personalizar la visualización que se muestra con 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 Cómo desglosar datos de forma más potente.

Los paneles admiten el desglose 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 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 las consultas que se ejecutan 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 proporciones, no pueden quitarlos. En general, estos filtros se usan para quitar datos que normalmente no deseas incluir. Por ejemplo, supongamos que, en la exploración Pedidos, solo quieres ver los pedidos que están completos o pendientes. Podrías agregar el siguiente código de LookML:

explore: orders {
  view_name: order
    filters: [status: "complete,pending"]
  }
}

Si el usuario quisiera ver pedidos con otros valores de estado, podría establecer ORDERS Status a % en la IU.

sql_always_where en Explorar

Si deseas aplicar una restricción de búsqueda que los usuarios no pueden cambiar, puedes usar sql_always_where. Además de las consultas que ejecutan los 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 al usuario una condición sql_always_where, a menos que mire el SQL subyacente de cualquier consulta que cree.

El siguiente ejemplo impide que los usuarios consulten los pedidos anteriores al 1/1/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 convertirse rápidamente en una carga demasiado pesada para 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 que se enumeran en la sección unless.

El siguiente ejemplo no realizará ningún cambio en la búsqueda 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 en orders.created_time.

  filters: [orders.created_time: "1 day"]
  unless: [created_date, shipped_time, shipped_date, orders.id, customer.name]
}