Patrones de LookML habituales

En esta página se describen los siguientes patrones habituales de LookML:

Campos de etiquetado (y nombres en la interfaz de usuario)

Looker convierte los nombres de los campos de LookML en las cadenas que muestra la interfaz de usuario combinando el nombre de la vista en una fuente de peso normal con el nombre abreviado del campo en negrita. Por ejemplo, un campo llamado Importe en la vista Pedidos se mostraría en la interfaz de usuario como Pedidos Importe. En esta página, ambos nombres de campo están en negrita y el nombre de la vista está en mayúsculas (IMPORTE DE PEDIDOS) para que la explicación sea más clara.

Si quieres 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 correspondiente 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 más fácil de leer:

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

Puede agrupar por una dimensión y contar entidades. Por ejemplo, si agrupa por País de los USUARIOS y Número de PEDIDOS, sabrá de qué país proceden sus pedidos. Sin embargo, a menudo resulta útil crear un recuento que se filtre por algún valor de dimensión. Por ejemplo, puede crear una medida y llamarla Pedidos de Francia:

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 quieres un campo que cuente los usuarios de la Unión Europea, puedes usar algo parecido a 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 quieres filtrar con una expresión matemática, asegúrate de escribirla 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 que han dado lugar a una venta" u otros casos de "el porcentaje de X que 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"
}

Usa el siguiente formato 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. Al multiplicar por 100.0, el primer recuento se convierte en un número de punto flotante, lo que hace que el resto de la expresión también se convierta en un número de punto flotante. Para evitar errores de división entre cero, NULLIF(value, 0) convierte el valor cero en nulo, lo que hace que el resultado sea nulo y evita que se produzca un error.

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

Usar conjuntos para obtener detalles

Una de las funciones más potentes de Looker es la posibilidad de desglosar los datos para ver las entidades subyacentes que componen un recuento u otra medida.

Cuando haces clic en una medida en la interfaz de usuario, Looker crea una consulta para localizar el conjunto de datos que compone la medida. Cada valor de cada dimensión de la fila de la tabla se añade a

Para mostrar los detalles, Looker necesita una lista específica de campos de desglose que se muestren cuando se haga clic en el valor de la medida. Cuando generas un modelo, el generador suele crear algunos campos de desglose iniciales. Además, puedes añadir campos de desglose manualmente. Por ejemplo, supongamos que está midiendo el Número de PEDIDOS por Estado de los USUARIOS de la última semana. En Looker, la consulta sería similar a la siguiente:

Estado USERSRecuento de PEDIDOS
California24
Texas5
Colorado4
Florida4
Illinois4

Si hace clic en 24 en la fila California, debería ver los 24 pedidos procedentes de California. Aunque Looker añade el filtro USERS State: California (Estado de los USUARIOS: California), no sabe qué campos quieres mostrar en el pedido. Primero, tendrás que 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 proporcionar a Looker la siguiente información:

  • Los campos que quiere mostrar al desglosar un recuento u otra medida
  • Los campos que quieras importar al unirte a una vista
  • Los campos que quieras indexar en una exploración

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

Conjuntos literales

Un conjunto literal es una forma sencilla de definir un conjunto en LookML, sobre todo cuando el conjunto se usa solo una vez. Un conjunto literal se crea declarando el conjunto como una matriz. Puedes declarar conjuntos literales mediante [].

Veamos un 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 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 de una exploración, quieres mostrar los campos id, name y city.

Al principio, declarar estos campos de forma literal 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 quieres añadir un campo nuevo (como customers.state), tendrías que editar ambas listas, a menos que usaras el parámetro set para crear conjuntos con nombre que puedas 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"]
    drill_fields: [detail*]      # show fields in the set "customers.detail"
  }
}

Los conjuntos de LookML son potentes por los siguientes motivos:

  • La redeclaración de conjuntos es acumulativa. Si declaras un conjunto en varios lugares, Looker incluirá todos los campos que se hayan declarado para el conjunto en todas las ubicaciones.
  • Puedes insertar conjuntos dentro de otros conjuntos escribiendo el nombre del otro conjunto seguido de un asterisco, por ejemplo, setname*.
  • Puedes quitar elementos de los conjuntos colocando un guion antes del nombre del campo, por ejemplo, -fieldname.

Personalizar visualizaciones de desglose

Si tu administrador de Looker ha habilitado la función de Labs Desglose visual, las visualizaciones de desglose de los looks y los explores no siempre se mostrarán de forma predeterminada en una tabla de datos. En este caso, puede personalizar la visualización que se muestra usando variables de Liquid en el parámetro link, tal como se indica en la página de documentación del parámetro link y en la página de prácticas recomendadas Desglose de datos más eficaz.

Los paneles de control admiten la función de desglose visual mediante el parámetro link sin necesidad de habilitar la función de Labs Desglose visual.

Filtrar 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 devuelvan 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 interfaz de usuario de Looker y, aunque los usuarios pueden cambiar el valor de filtro predeterminado que proporciones, no podrán eliminar los filtros. Por lo general, estos filtros se usan para eliminar datos que normalmente no quieres incluir. Por ejemplo, supongamos que, en la exploración Pedidos, solo quieres ver los pedidos que se han completado o están pendientes. Podrías añadir el siguiente código LookML:

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

Si el usuario quisiera ver los pedidos con otros valores de estado, podría definir Estado de los pedidos como % en la interfaz de usuario.

sql_always_where en Explorar

Si quieres aplicar una restricción de consulta que los usuarios no puedan cambiar, puedes usar sql_always_where. Además de las consultas realizadas por usuarios humanos, la restricción se aplicará a los paneles de control, los Looks programados y la información insertada que dependa de ese Exploración. Una condición sql_always_where no se muestra al usuario, a menos que consulte el código SQL subyacente de las consultas que cree.

En el siguiente ejemplo, se impide que los usuarios vean los pedidos anteriores al 1 de enero del 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 a la hora de hacer consultas, ya que las consultas ilimitadas pueden sobrecargar rápidamente la base de datos. LookML ofrece una forma de abordar este problema mediante conditionally_filter.

Utilice el parámetro conditionally_filter para aplicar un filtro a la consulta, a menos que el usuario ya haya añadido un filtro para uno de los campos que se indican en la sección unless.

En el siguiente ejemplo, no se hará ningún cambio en la consulta del usuario si este ha aplicado un filtro en uno o varios de estos campos: created_date, shipped_time, shipped_date, orders.id o customer.name. Si el usuario no ha filtrado por ninguno de esos campos, Looker añadirá 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]
}