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
  }
}

Filtrado de 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 resulta útil crear un recuento filtrado 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 un campo que contara 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 porcentajes, como "el porcentaje de elementos 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 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. La multiplicación por 100.0 convierte el primer recuento en un número de punto flotante y, así, 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)

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 medición.

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

Para mostrar el detalle, Looker necesita una lista específica de campos de desglose para mostrar cuándo 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 estás midiendo ORDERS Count por Users State durante la última semana. En Looker, la consulta se vería similar a la siguiente:

USUARIOS EstadoCantidad 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 USUARIOS State: California, Looker no sabe qué campos quieres mostrar en el orden. 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

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

Conjuntos literales

Un conjunto literal es una forma sencilla de definir un conjunto en LookML, especialmente cuando el conjunto se usa solo una vez. Para crear un conjunto literal, se lo declara 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 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 desglosa el campo Recuento o En la cantidad de California en una exploración, debes 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 por 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 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 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 desglose de datos 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 sección de exploración Pedidos, solo quieres ver los pedidos completados 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 depende de 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

Es necesario prestar atención a las tablas muy grandes cuando se realizan consultas, ya que las consultas ilimitadas pueden volverse muy complicadas para la base de datos. LookML proporciona una forma de abordar esto en el formato 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 aparecen en la sección unless.

En el siguiente ejemplo, no se modificará 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 en orders.created_time.

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