Patrones comunes de LookML

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

• Etiquetado de campos (y nombres en la IU)
• Cómo filtrar los recuentos por una dimensión
• Porcentajes
• Uso de conjuntos para obtener detalles de desglose
• Cómo filtrar conjuntos de resultados

Etiquetado de campos (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 fuente de peso normal con el nombre corto del campo en negrita. Por ejemplo, un campo llamado Importe en la vista Pedidos aparecería en la IU como Pedidos Importe. En esta página, ambos nombres de campos están en negrita y el nombre de la vista está en mayúsculas (ORDERS Amount) 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 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:

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

Puedes agrupar por una dimensión y contar entidades. Por ejemplo, si agrupas por País de los USUARIOS y Recuento de PEDIDOS, sabrás de qué países provienen tus pedidos. Sin embargo, a menudo es útil crear un recuento que se filtre según algún valor dimensional. Por ejemplo, puedes crear una nueva métrica y llamarla 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 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 incluirla 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 cualquier otro caso 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 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, 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 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 obtener detalles

Una de las funciones más potentes de Looker es la capacidad de explorar los datos en detalle para ver las entidades subyacentes que componen un recuento o alguna otra métrica.

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

Para mostrar el detalle, Looker necesita una lista especificada de campos de desglose que se mostrarán 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 agregar campos de desglose por tu cuenta. Por ejemplo, supongamos que mides el recuento de PEDIDOS por Estado de los USUARIOS en la última semana. En Looker, la consulta se vería de la siguiente manera:

Si haces clic en 24 en la fila California, es posible que esperes ver los 24 pedidos que se originaron en California. Si bien Looker agrega el filtro Estado de los USUARIOS: California, no sabe qué campos deseas mostrar en el pedido. Primero, 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). Usas conjuntos para proporcionar la siguiente información a Looker:

• Los campos que deseas mostrar cuando profundizas en un recuento o en otra métrica
• Los campos que deseas importar cuando te unes a una vista
• Los campos que deseas 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 de literales

Un conjunto literal es una forma sencilla de definir un conjunto en LookML, en especial cuando el conjunto se usa solo una vez. Para crear un conjunto literal, declara el conjunto como un array. Puedes declarar conjuntos 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 explora en detalle el campo Recuento o el campo Recuento en California en un Explorar, deseas mostrar los campos id, name y city.

En un principio, declarar estos campos de forma literal 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 usaras el parámetro set para crear conjuntos con nombre que puedes 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 por los siguientes motivos:

• 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*.
• Puedes quitar elementos de los conjuntos colocando un guion antes del nombre del campo, por ejemplo, -fieldname.

Cómo personalizar las visualizaciones de desglose

Si tu administrador de Looker habilitó la función de Labs Exploración visual, las visualizaciones de exploración de Looks 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 de Liquid 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 Exploración 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 Desglose visual.

Cómo filtrar conjuntos de resultados

LookML proporciona un conjunto de operaciones de filtro que se pueden aplicar a los campos y a las Exploraciones para filtrar los 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 Explorar. Los filtros aparecerán en la IU de Looker y, aunque los usuarios pueden cambiar el valor del filtro predeterminado que proporciones, no podrán quitar los filtros. Por lo general, estos filtros se usan para quitar los datos que normalmente no deseas incluir. Por ejemplo, supongamos que, en el Explorador Pedidos, solo querías 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 Estado de los PEDIDOS en % 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 los usuarios humanos, la restricción se aplicará a los paneles, las vistas programadas y la información incorporada que dependa de esa función Explorar. Una condición sql_always_where no se muestra al usuario, a menos que mire el código 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 cierta consideración al realizar consultas, ya que las consultas ilimitadas pueden volverse rápidamente demasiado pesadas para la base de datos. LookML proporciona una forma de abordar este problema con conditionally_filter.

Usas 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 indican en la sección unless.

En el siguiente ejemplo, no se realizará ningún cambio en la búsqueda del usuario si este aplicó un filtro en uno o más de los siguientes campos: created_date, shipped_time, shipped_date, orders.id o customer.name. Si el usuario no aplicó filtros en 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]
}