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 campo de LookML en las cadenas que muestra 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, los nombres de los dos campos están en negrita, y el nombre de la vista está en mayúscula (ORDERS Amount) para que el debate sea más claro.

Si quieres que un campo tenga un nombre diferente del nombre de columna en una tabla, cambia el nombre del campo y usa el parámetro sql para vincular el campo con la columna adecuada en 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 por humanos:

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

Puedes agrupar por una dimensión y contar entidades. Al agrupar por País de los USUARIOS, Recuento de PEDIDOS te indicará de dónde provienen tus pedidos según el país. Sin embargo, suele ser útil crear un recuento filtrado por algún valor dimensional. Por ejemplo, puedes realizar una nueva medida y asignarle el nombre 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 a los usuarios de la UE, podrías usar algo como esto:

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 bien otras instancias del "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 ambas.

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 da como resultado números enteros. La multiplicación por 100.0 convierte el primer recuento en un número de punto flotante, con lo cual se 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 cero en nulo, lo que hace que el resultado sea nulo y evita un error.

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

Cómo usar 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 cualquier otra medida.

Cuando haces clic en una medición en la IU, Looker crea una consulta nueva para localizar el conjunto de datos que conforman la medición. Cada valor para cada dimensión de la fila de la tabla se agrega

Para mostrar los detalles, Looker necesita una lista específica de campos de desglose a fin de mostrar cuándo se hizo clic en el valor de la medición. Cuando generas un modelo, el generador suele crear algunos campos de desglose iniciales para ti. Además, puedes agregar campos de desglose tú mismo. Por ejemplo, supongamos que estás midiendo el Recuento de PEDIDOS por el Estado de los USUARIOS durante la última semana. En Looker, la consulta debería ser similar a la siguiente:

Estado de USUARIOSRecuento de ORDERS
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 Estado USUARIOS: California, Looker no sabe qué campos quieres mostrar en el pedido. Primero necesitas 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). Puedes usar conjuntos para proporcionarle a Looker la siguiente información:

  • Los campos que deseas mostrar cuando desglosas un recuento o alguna otra medición
  • Los campos que deseas importar cuando te unes a una vista
  • Los campos que quieres indexar 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 literales

Un conjunto literal es una forma directa de definir un conjunto en LookML, en especial cuando el conjunto se usa solo una vez. Un conjunto literal se crea mediante la declaración del conjunto 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 quieres mostrar son id, name y city.

En la medición, 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 explore en detalle los campos Recuento o Recuento en California de una exploración, deberás mostrar los campos id, name y city.

En un principio, declarar estos campos literalmente podría 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 quisieras agregar un campo nuevo (como customers.state), tendrías que editar ambas listas, a menos que hayas usado el parámetro set para crear conjuntos con nombre que puedas 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"]
    drill_fields: [detail*]      # show fields in the set "customers.detail"
  }
}

Los conjuntos de LookML son potentes en 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 escribiendo 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.

Cómo personalizar las visualizaciones de desglose

Si el administrador de Looker habilitó la función de Labs Desglose visual, las visualizaciones de desglose de Examinar y explorar no siempre se establecerán de forma predeterminada como 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 para un 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 de exploración visual de 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 dentro de 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. Generalmente, estos filtros se usan para quitar datos que normalmente no deseas incluir. Por ejemplo, supongamos que, en la exploración de pedidos, solo deseas ver los pedidos que estaban completos o pendientes. Podrías agregar el siguiente código de LookML:

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

Si el usuario desea ver los pedidos con otros valores de estado, puede configurar ORDERS Status como % en la IU.

sql_always_where en Explorar

Si deseas aplicar una restricción de búsqueda que los usuarios no puedan cambiar, 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 basa en esa exploración. No se muestra una condición sql_always_where al usuario, a menos que mire el SQL subyacente de las consultas que cree.

En el siguiente ejemplo, se impide que los usuarios vean 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 de atención al momento 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 forma de conditionally_filter.

Usa el parámetro conditionally_filter para aplicar un filtro a la búsqueda, a menos que el usuario ya haya agregado un filtro para uno de los campos que se enumeran 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]
}