Patrones comunes de LookML

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

• Etiqueta campos (y nombres en la IU)
• Filtrado de recuentos por dimensión
• Porcentajes
• Cómo usar conjuntos para los detalles desglosados
• Cómo filtrar conjuntos de resultados

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 quieres 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:

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 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 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 forma de porcentajes, como "el porcentaje de elementos mostrados", "el porcentaje de correos electrónicos que generaron una venta", u otros ejemplos 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 componen un recuento o alguna otra medición.

Cuando haces clic en una medición en la IU, Looker crea una nueva para localizar el conjunto de datos que constituye la medición. Cada valor de cada dimensión de 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 USER State durante la última semana. En Looker, la consulta se vería similar a la siguiente:

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 USERS State: 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, medida y filtro). Usas conjuntos para darle 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 unes una vista
• Los campos que deseas indexar 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. 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 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.

Inicialmente, 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 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 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 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 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 Cómo desglosar datos de forma 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.

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 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. 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 en % 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]
}