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 recuentos por una dimensión
• Porcentajes
• Cómo usar conjuntos para desglosar los detalles
• Cómo filtrar conjuntos de resultados

Etiquetas 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 grosor normal con el nombre corto del campo en negrita. Por ejemplo, un campo llamado Cantidad en la vista Pedidos aparecerá en la IU como Cantidad de Pedidos. 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 deseas que un campo tenga un nombre diferente al nombre de su columna en una tabla, cambia el nombre del campo y usa el parámetro sql para vincularlo 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 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 una dimensión

Puedes agrupar por una dimensión y contar entidades. Si agrupas por País de USUARIOS, Cantidad 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, podrías crear una nueva medición y llamarla COUNT Francia de ORDERS:

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 cuente 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 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 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 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 para 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 suele crear algunos campos de desglose iniciales por ti. Además, puedes agregar campos de desglose por tu cuenta. Por ejemplo, supongamos que mides el Cantidad de PEDIDOS por Estado de USUARIOS en la última semana. En Looker, la consulta se vería de la siguiente manera:

Estado de USERS	Cantidad de PEDIDOS
California	24
Texas	5
Colorado	4
Florida	4
Illinois	4

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 DE USUARIOS: California, no sabe qué campos deseas mostrar en el pedido. Primero, debes usar un conjunto para declarar esos campos en tu modelo.

En LookML, un conjunto es una lista de nombres de campos (dimensión, métrica y filtro). Usas conjuntos para proporcionarle a Looker la siguiente información:

• Los campos que deseas mostrar cuando desglosas un recuento o alguna otra medida
• 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 particular, cuando se usa solo una vez. Para crear un conjunto literal, debes declararlo 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 desglosa el campo Cantidad o el campo Cantidad en California en una exploración, deseas mostrar los campos id, name y city.

En 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 quieres agregar un campo nuevo (como customers.state), deberás editar ambas listas, a menos que uses el parámetro set para crear conjuntos con nombre que puedas mantener en un lugar y usar en varios.

El siguiente código crea un conjunto customers.detail y dirige 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 de las siguientes maneras:

• La nueva declaració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.
• Para incorporar conjuntos dentro de otros, 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 Visual Drilling, las visualizaciones de desglose de Look y Explore no siempre se mostrarán de forma predeterminada en una tabla de datos. 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 Análisis 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 Visual Drilling.

Cómo 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 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 predeterminado que proporcionas, no pueden quitarlos. Por lo general, estos filtros se usan para quitar datos que normalmente no quieres incluir. Por ejemplo, supongamos que, en la exploración Pedidos, solo quieres ver los pedidos que están completos o pendientes. Puedes 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 en % en la IU.

sql_always_where en Explorar

Si deseas aplicar una restricción de consulta 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 se base 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 crea.

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