Mejoras de LookML

Descripción general

Con los refinamientos de LookML, puedes adaptar una vista o Explorar existente sin editar el archivo de LookML que la contiene. Esto es ideal para lo siguiente:

Por ejemplo, si tienes el siguiente archivo de vista en tu proyecto:

view: flights {
  sql_table_name: flightstats.accidents ;;

  dimension: id {
    label: "id"
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }
}

Puedes definir mejor la vista flights, como se muestra en el siguiente ejemplo: Usa el parámetro view con el mismo nombre de vista, pero agrega un signo más (+) delante del nombre para indicar que se trata de un perfeccionamiento de una vista existente.

Este perfeccionamiento agrega una dimensión air_carrier a la vista flights existente:

view: +flights {
  dimension: air_carrier {
    type: string
    sql: ${TABLE}.air_carrier ;;
  }
 }

Este perfeccionamiento puede ir en cualquier archivo de LookML del proyecto, como un archivo de modelo, un archivo de vista o su propio archivo de LookML dedicado. Consulta la sección Usa mejoras en tu proyecto de LookML para descubrir cómo funciona.

El refinamiento combinado con el LookML original tiene el resultado final como si este fuera el LookML original para la vista:

view: flights {
  sql_table_name: flightstats.accidents ;;

  dimension: id {
    label: "id"
    primary_key: yes
    type: number
    sql: ${TABLE}.id ;;
  }

  dimension: air_carrier {
    type: string
    sql: ${TABLE}.air_carrier ;;
  }
}

En la IU de Looker, los usuarios verán la dimensión Air Carrier, como si hubieras agregado la dimensión al archivo de vista original.

Consulta el siguiente ejemplo para obtener información más detallada sobre la implementación.

Mejoras en comparación con extensiones

Looker también admite extending objetos de LookML. La extensión es útil cuando deseas crear una copia nueva de una vista existente o de Exploración para poder agregarle objetos nuevos. Por ejemplo, puedes crear una vista base que defina todos tus campos y, luego, crear varias vistas nuevas que extiendan la vista base. Estas nuevas vistas se pueden modificar para ocultar ciertos campos en la vista base o para cambiar las definiciones o etiquetas de los campos de la vista base.

Las mejoras son útiles cuando deseas modificar una vista o una exploración existentes con algunos ajustes o ajustes a ciertos objetos, pero no quieres crear copias de la vista o la exploración. Las mejoras son ideales para situaciones en las que no puedes o no quieres modificar la vista base o Explorar, y para las situaciones en las que crear una vista o una exploración nuevas implicarían cambios importantes en otras referencias de LookML. Consulta la sección Ejemplo de esta página para ver un ejemplo de este caso de uso.

En la mayoría de los casos de uso, las mejoras son una alternativa más simple y clara que extends.

Los desarrolladores avanzados de LookML pueden usar el parámetro extends en un perfeccionamiento de LookML. Para obtener más información, consulta la sección Las mejoras pueden contener extensiones de esta página.

Los ajustes anulan la mayoría de los parámetros.

Es importante tener en cuenta que, en la mayoría de los casos, un perfeccionamiento anulará la configuración original de un objeto. En el siguiente ejemplo, la vista original tiene una dimensión oculta (hidden: yes):

view: faa_flights {
  dimension: carrier {
    hidden: yes
  }
}

Y, en otro archivo, se perfeccionó esa dimensión con hidden: no:


include: "/views/faa_flights.view.lkml"

view: +faa_flights {
  dimension: carrier {
    hidden: no
  }
}

El último perfeccionamiento tiene prioridad, por lo que se aplica hidden: no y la dimensión se mostrará en la vista final.

En algunos casos, las mejoras son aditivas en lugar de anuladas. Consulta la sección Algunos parámetros son aditivos de esta página para obtener más información.

Algunos parámetros son aditivos

En muchos casos, si el perfeccionamiento contiene el mismo parámetro que el objeto que se perfecciona, este anulará los valores de los parámetros del objeto refinado.

Sin embargo, las mejoras pueden ser aditivas para algunos parámetros, lo que significa que los valores del objeto base se usan junto con los valores del objeto mejor definido.

Los siguientes parámetros son aditivos:

Por ejemplo, esta es una vista que tiene una dimensión name con un parámetro link:

view: carriers {
  sql_table_name: flightstats.carriers ;;

  dimension: name {
    sql: ${TABLE}.name ;;
    type: string
    link: {
      label: "Google {{ value }}"
      url: "http://www.google.com/search?q={{ value }}"
      icon_url: "http://google.com/favicon.ico"
    }
  }
}

Este es un perfeccionamiento de la vista carriers, con una dimensión name que tiene valores diferentes para el parámetro link:


include: "/views/carriers.view.lkml"

view: +carriers {
  label: "Refined carriers"

  dimension: name {
    sql: ${TABLE}.name ;;
    type: string
    link: {
      label: "Dashboard for {{ value }}"
      url: "https://docsexamples.dev.looker.com/dashboards/307?Carrier={{ value }}"
      icon_url: "https://www.looker.com/favicon.ico"
    }
  }
}

En la vista carriers mejor definida, los dos parámetros link son aditivos, por lo que la dimensión name mostrará ambos vínculos.

Las mejoras se aplican en orden

Un objeto se puede definir mejor varias veces y en varios lugares, lo que permite a los desarrolladores de Looker aplicar mejoras de muchas formas creativas. Sin embargo, esto también significa que los desarrolladores deben ser muy conscientes del orden en el que se aplican las mejoras:

  • Dentro de un proyecto, las mejoras se aplican en el orden en que se incluyen sus archivos. Las mejoras de los archivos incluidos en último lugar anularán las de los archivos incluidos anteriormente.
  • En un solo archivo, las mejoras se aplican línea por línea hacia abajo. Las mejoras con el número de línea más alto se aplican en último lugar y anularán las mejoras anteriores si hay conflictos.

Por ejemplo, en el siguiente archivo de vista, se definen dos mejoras en la vista faa_flights. La primera mejora oculta una dimensión (hidden: yes), mientras que la segunda muestra la dimensión (hidden: no). Cuando hay conflictos como este, prevalecerá el perfeccionamiento más detallado en el archivo: 

include: "//e_faa_original/views/faa_flights.view.lkml"

view: +faa_flights {
  dimension: carrier {
    hidden: yes
  }
}

view: +faa_flights {
  dimension: carrier {
    hidden: no
  }
}

La lógica es similar para incluir varios archivos en un proyecto: las mejoras en el último archivo enumerado en las inclusiones tendrán prioridad. Por ejemplo, si un archivo de modelo incluye estos archivos:

include: "/refinements/distance_analysis.lkml"
include: "/refinements/finishing_touches.lkml"

Todas las mejoras en distance_analysis.lkml se aplicarán primero y, luego, en el archivo finishing_touches.lkml. Si hay algún conflicto, prevalecerán las mejoras en el último archivo, finishing_touches.lkml.

Uso de final: yes para evitar que se definan más detalles

Como se describió anteriormente, el mismo objeto se puede definir mejor varias veces en varios lugares, y el último perfeccionamiento anulará todos los ajustes anteriores.

Si tienes una mejora que quieres que se considere la mejora final de la vista o la exploración, puedes agregar la marca final: yes a la mejora. El IDE de Looker mostrará un error de LookML si hay mejoras existentes que se aplicarían después de este perfeccionamiento final o si un desarrollador intenta agregar un perfeccionamiento nuevo que se aplicaría después de este perfeccionamiento final. Por ejemplo, la segunda mejora en este archivo de vista crearía un error de LookML porque la mejora anterior tiene la marca final: yes:

include: "//e_faa_original/views/faa_flights.view.lkml"

view: +faa_flights {
  final: yes
  dimension: carrier {
    hidden: yes
  }
}

view: +faa_flights {
  dimension: carrier {
    hidden: no
  }
}

Agregar la marca final: yes a una mejora es una buena manera de verificar que tus ajustes se apliquen en el orden deseado.

Los ajustes pueden contener extensiones

Los desarrolladores avanzados de LookML pueden usar un parámetro extends dentro de un refinamiento de LookML, que agrega el objeto extendido al objeto que se está perfeccionando.

Para resumir el comportamiento de extends y las mejoras, haz lo siguiente:

  • Cuando se extiende un objeto, se crea una copia nueva de este y, luego, se compila sobre él. Por ejemplo, puedes crear una vista base que defina todos tus campos y, luego, crear varias vistas nuevas que extiendan la vista base. Cada una de estas nuevas vistas incorporará una copia de la vista base y, a partir de allí, un desarrollador puede agregar diferentes campos, filtros y otras propiedades para modificar lo que hay en la vista base. La idea es que empieces con un objeto base y lo uses de diferentes maneras en otros objetos. (Puedes consultar la página de documentación Cómo reutilizar código con extensiones para ver una discusión completa sobre cómo trabajar con extensiones).
  • Refinar un objeto agrega una capa de modificaciones al objeto, pero, a diferencia de la extensión, el refinamiento no hace varias copias del objeto. La idea es compilar sobre un objeto base sin modificar su LookML original.

A modo de ejemplo del uso estándar de las mejoras, a continuación, se incluye una exploración llamada orders y la función Explorar +orders que la define mejor:

explore: orders {
  view_name: orders
  # other Explore parameters
}

explore: +orders {
  label: "Orders Information"
  # other Explore parameters to build on the original Explore
}

Además, puedes agregar un perfeccionamiento que incluya un extends. A partir del ejemplo, aquí es la misma exploración de orders. Sin embargo, además, hay una exploración base llamada users_base, y ahora el perfeccionamiento de +orders tiene un parámetro extends que incorpora users_base:


explore: users_base {
  view_name: users
  extension: required
  # other Explore parameters
}

explore: orders {
  view_name: orders
  # other Explore parameters
}

explore: +orders {
  label: "Orders Information"
  extends: [users_base]
  # other Explore parameters to build on the original Explore
}

Lo especial de esto es que el refinamiento de +orders tiene un extends dentro. El resultado es que la vista de +orders ahora extenderá la exploración de users_base.

Cómo Looker implementa extends en las mejoras

La extensión de un objeto dentro de un perfeccionamiento es un concepto avanzado de LookML. Antes de usar extends en una mejora, debes comprender en profundidad lo siguiente:

  • Cómo Looker implementa extends: Si un elemento de LookML se define en el objeto externo y en el objeto ing que se extiende, se usa la versión en el objeto que extiende, a menos que el parámetro sea aditivo. Consulta la página de documentación Vuelve a usar código con extensiones para obtener más información.
  • Cómo Looker implementa los perfeccionamientos: Si un elemento de LookML se define con varios perfeccionamientos, este último anula los anteriores. Consulta la sección Las mejoras se aplican en orden de esta página para obtener más detalles.

Por último, deberías comprender cómo Looker combina estos principios para implementar extends en las mejoras. Este es el orden en que Looker implementa, y cada paso anula el anterior en caso de conflictos:

  1. Valores de extends especificados en el objeto
  2. Valores de extends especificados en los ajustes del objeto
  3. Valores del objeto
  4. Valores de las mejoras del objeto

A modo de ejemplo, el siguiente es un ejemplo que sigue el valor del parámetro label en cada paso de la implementación:

explore: orders_base {
  label: "Orders Base"
  view_name: orders
  extension: required
}

explore: users_base {
  label: "Users Base"
  view_name: users
  extension: required
}

explore: orders {
  label: "Orders"
  extends: [orders_base]
}

explore: +orders {
  label: "Orders Refined"
  extends: [users_base]
}

A continuación, se muestra cómo Looker implementa el valor de label para la exploración de orders en este ejemplo:

  1. Valores de extends especificados en el objeto. Dado que la exploración de orders tiene un parámetro extends, Looker comienza con los elementos de LookML del objeto que se está extendiendo, que en este caso es la exploración de orders_base. En este punto, el valor de label es "Orders Base".
  2. Valores de extends especificados en mejoras del objeto. Como orders tiene un perfeccionamiento, y este último tiene un parámetro extends, Looker aplica elementos de LookML de la extensión de la mejora, que en este caso es la exploración de users_base. En este punto, el valor de label es "Base de usuarios".
  3. Valores del objeto. Ahora que se abordaron todas las extensiones, Looker aplica elementos del objeto que se extiende, que en este caso es la exploración de orders. Si hay algún conflicto, el objeto que se extiende gana. Ahora, el valor de label es "Orders".
  4. Valores de las mejoras del objeto. Por último, Looker aplica elementos de cualquier perfeccionamiento de la exploración de orders. Si hay algún conflicto, el objeto de perfeccionamiento gana. Por lo tanto, ahora, el valor de label es "Pedidos refinados".

Los extends de mejora son acumulativos

Como se describe en la sección Los ajustes anulan los parámetros de esta página, estos suelen anular la configuración original de un objeto. Este no es el caso del parámetro extends. Cuando se usa extends en un perfeccionamiento, el valor del parámetro extends se agrega a la lista de elementos extendidos en el objeto original o en mejoras anteriores, si corresponde. Luego, si hay conflictos, se da prioridad al último elemento de la cadena de extensiones.

Por ejemplo, esta es una exploración base llamada orders_base y una exploración orders que extiende la base. Además, hay una exploración de users_base y el refinamiento de +orders que extiende users_base:

explore: orders_base {
  view_name: orders
  extension: required
  # other Explore parameters
}

explore: users_base {
  view_name: users
  extension: required
  # other Explore parameters
}

explore: orders {
  extends: [orders_base]
  # other Explore parameters to build on the base Explore
}

explore: +orders {
  extends: [users_base]
  # other Explore parameters to build on the base Explores
}

La exploración de orders extiende la orders_base, luego, las mejoras en +orders agregan users_base a la lista de extends. Como resultado, Explorar con +orders ahora extenderá orders_base y users_base, como si este fuera el LookML original para Explorar:

explore: orders {
  extends: [orders_base, users_base]
}

Luego, si hay conflictos, se da prioridad al último elemento de la cadena de extensiones. En este ejemplo, los elementos de users_base anularían cualquier elemento en conflicto en orders_base.

El concepto de extender más de un objeto a la vez se analiza en la página de documentación Vuelve a usar código con extensiones.

Por último, debes tener en cuenta que, en este ejemplo, el orden de los parámetros explore no importa. Sin embargo, en los casos en los que el mismo objeto se perfecciona con varios refinamientos, el orden de estas opciones sí importa. Como se describe en la sección Las mejoras se aplican en orden de esta página, el último perfeccionamiento de un archivo anula los anteriores.

Usa mejoras en tu proyecto de LookML

Estos son algunos pasos generales para definir mejor las vistas y las exploraciones en tu proyecto:

  1. Identifica la vista o la función Explorar que deseas definir mejor.
  2. Decide dónde quieres ubicar tus refinamientos. Puedes agregar mejoras en cualquier archivo de LookML existente o puedes crear archivos de LookML independientes para tus ajustes. (Consulta el procedimiento para crear un archivo de prueba de datos en la página de documentación Información sobre otros archivos del proyecto para ver un ejemplo de cómo crear archivos genéricos de LookML).
  3. Usa el parámetro include para incorporar tus definiciones en el modelo:
    • En el archivo en el que escribes tus ajustes, debes incluir los archivos de LookML que estás definiendo mejor. El IDE de Looker mostrará advertencias si intentas definir mejor un objeto que no está incluido.
    • En tu archivo de modelo, incluye los archivos en los que se definen tus ajustes. Puedes combinar archivos y usar inclusiones de maneras muy creativas; consulta la sección Uso de mejoras para agregar capas a tu modelo en esta página para obtener más detalles.

Ejemplo

Perfeccionar los objetos de LookML es una forma sencilla de adaptar vistas y exploraciones sin tener que editar el LookML original. Esto resulta especialmente útil cuando las vistas y las exploraciones son de solo lectura en tu proyecto, como sucede con los archivos importados de otros proyectos. Este es un ejemplo de cómo definir mejor una exploración.

Este es el LookML para la exploración de aircraft:


explore: aircraft {
  join: aircraft_types {
    type: left_outer
    sql_on: ${aircraft.id} = ${aircraft_types.id} ;;
    relationship: many_to_one
  }

  join: aircraft_engine_types {
    type: left_outer
    sql_on: ${aircraft.id} = ${aircraft_engine_types.id} ;;
    relationship: many_to_one
  }
}

Esta exploración contiene varias vistas, cada una de las cuales tiene muchas dimensiones.

Ahora, otro proyecto de LookML llamado e_faa_refined importa el archivo aircraft de Explorar. En el proyecto e_faa_refined, puedes aplicar mejoras para simplificar drásticamente la función Explorar de aircraft.

Como el archivo Explorar de aircraft es importado, no puedes editarlo directamente. En su lugar, puedes definirla mejor. Aquí hay un ejemplo de un archivo separado llamado refinements.lkml que contiene este LookML:

include: "//e_faa_original/Explores/aircraft.explore.lkml"

explore: +aircraft {
  label: "Aircraft Simplified"
  fields: [aircraft.aircraft_serial, aircraft.name, aircraft.count]
}

El archivo refinements.lkml contiene lo siguiente:

  • El parámetro include para incorporar el archivo aircraft.explore.lkml original del proyecto importado (consulta la página de documentación Cómo importar archivos de otros proyectos para obtener detalles sobre cómo hacer referencia a los archivos del proyecto importados).
  • Más mejoras en la exploración de aircraft:
    • El signo + frente al nombre de Explorar indica un ajuste para definir una exploración existente.
    • El parámetro label cambia la etiqueta de la Exploración a "Aeronaves simplificadas".
    • El parámetro fields especifica que solo se mostrarán tres campos en Explorar.

El resultado final es como si fueran las vistas originales de exploración y aircraft de aircraft:

explore: aircraft {
  label: "Aircraft Simplified"
  }

view: aircraft {
  sql_table_name: flightstats.aircraft ;;

  dimension: aircraft_serial {
    type: string
    sql: ${TABLE}.aircraft_serial ;;
  }

  dimension: name {
    type: string
    sql: ${TABLE}.name ;;
  }

  measure: count {
    type: count
  }
}

Si deseas ver un ejemplo de cómo usar mejoras para personalizar una vista única para varios casos de uso, consulta la receta del libro de recetas Maximiza la reutilización de código con LookML de DRY: Personaliza una sola vista base para varios casos de uso.

Otros casos de uso para las mejoras

Como se mencionó anteriormente, las mejoras son ideales para adaptar objetos de LookML que son de solo lectura, como los bloques de Looker o los archivos importados.

Pero una vez que tengas la idea de agregar perfeccionamientos e incluirlos en tus modelos, puedes hacer cosas muy geniales con tus proyectos, como se describe en los siguientes ejemplos.

Cómo usar mejoras para agregar análisis

Puedes usar mejoras para agregar análisis a tu modelo sin tocar los archivos de LookML originales. Por ejemplo, si hay un proyecto en el que las vistas y las exploraciones se generan a partir de tablas en tu base de datos y se almacenan en un archivo de LookML llamado faa_basic.lkml, puedes crear un archivo faa_analysis.lkml en el que uses mejoras para agregar análisis. Este es un ejemplo de una nueva tabla derivada llamada distance_stats que tiene un análisis de distancia. En este ejemplo, se muestra un perfeccionamiento de la exploración flights existente del archivo faa_basic.lkml que une la tabla derivada distance_stats a la exploración de flights. Además, en la parte inferior del ejemplo, la vista flights existente se define mejor para agregar nuevos campos del análisis:

include: "faa_basic.lkml"

explore: +flights {
  join: distance_stats {
    relationship: one_to_one
    type: cross
  }
}

view: distance_stats {
  derived_table: {
    explore_source: flights {
      bind_all_filters: yes
      column: distance_avg {field:flights.distance_avg}
      column: distance_stddev {field:flights.distance_stddev}
    }
  }
  dimension: avg {
    type:number
    sql: CAST(${TABLE}.distance_avg as INT64) ;;
  }
  dimension: stddev {
    type:number
    sql: CAST(${TABLE}.distance_stddev as INT64) ;;
  }
}
view: +flights {
  measure: distance_avg {
    type: average
    sql: ${distance} ;;
  }
  measure: distance_stddev {
    type: number
    sql: STDDEV(${distance}) ;;
  }
  dimension: distance_tiered2 {
    type: tier
    sql: ${distance} ;;
    tiers: [500,1300]
  }
}

Cómo usar mejoras para agregar capas a tu modelo

Otro caso de uso interesante para las mejoras es agregar capas a tu proyecto. Puedes crear varios archivos de perfeccionamiento y, luego, incluirlos estratégicamente para agregar capas.

Por ejemplo, en el proyecto de FAA, hay un archivo faa_raw.lkml que contiene todas las vistas y exploraciones que se generaron a partir de tablas de tu base de datos. Este archivo tiene una vista para cada tabla de la base de datos, cada una con una dimensión para cada columna de la base de datos.

Además del archivo sin procesar, puedes crear un archivo faa_basic.lkml para agregar una capa nueva con mejoras básicas, por ejemplo, agregar uniones a tus exploraciones o mediciones a tus vistas de la siguiente manera:

include: "faa_raw.lkml"

explore: +flights {
  join: carriers {
    sql_on: ${flights.carrier} = ${carriers.name} ;;
  }
}

view: +flights {
  measure: total_seats {
    type: sum
    sql: ${aircraft_models.seats} ;;
  }
}

Luego, puedes agregar un archivo faa_analysis.layer.lkml para incluir una nueva capa con análisis (consulta la subsección Cómo usar mejoras para agregar análisis para ver un ejemplo de un archivo de análisis).

A partir de ahí, solo debes incluir todos los archivos de perfeccionamiento en el archivo de modelo. También puedes usar el archivo de modelo para agregar mejoras que apunten tus vistas a las tablas de la base de datos a las que quieres hacer referencia:

connection: "publicdata_standard_sql"

include: "faa_raw.lkml"
include: "faa_basic.lkml"
include: "faa_analysis.lkml"

view: +flights {
  sql_table_name: lookerdata.faa.flights;;
}
view: +airports {
  sql_table_name: lookerdata.faa.airports;;
}
view: +aircraft {
  sql_table_name: lookerdata.faa.aircraft;;
}
view: +aircraft_models{
  sql_table_name: lookerdata.faa.aircraft_models;;
}
view: +carriers {
  sql_table_name: lookerdata.faa.carriers;;
}

Puedes duplicar este archivo de modelo y apuntar a diferentes tablas de bases de datos o puedes incluir diferentes archivos de perfeccionamiento que hayas creado para definir otras capas que desees en tu modelo.

Usa mejoras para las PDT

Como se describe en la sección Perfeccionamientos en comparación con extensiones de esta página, una extensión crea una copia nueva del objeto que se está extendiendo. En el caso de las tablas derivadas persistentes (PDT), no debes usar extensiones, ya que cada extensión de una PDT creará una copia nueva de la tabla en tu base de datos.

Sin embargo, puedes agregar mejoras a la vista de la PDT, ya que estas no crean una copia nueva del objeto que se está definiendo.

Usa metadatos para ver las mejoras de un objeto

Puedes hacer clic en un parámetro explore o view en el IDE de Looker y usar el panel de metadatos para ver las mejoras en el objeto. Consulta la página de documentación Metadatos para objetos de LookML para obtener más información.

Aspectos para tener en cuenta

Proyectos con localización

Cuando definas mejor un objeto, ten en cuenta que las reglas de localización también se aplican a tus definiciones. Si estás definiendo mejor un objeto y, luego, nuevas etiquetas o descripciones, debes proporcionar definiciones de localización en los archivos de cadenas de configuración regional de tu proyecto. Consulta la página de documentación Localiza tu modelo de LookML para obtener más información.