Refinamientos de LookML

Descripción general

Con las mejoras de LookML, puedes adaptar una vista o una Exploración 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 es una definición mejor de una vista existente.

Esta definición agrega una dimensión air_carrier a la vista flights existente:

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

Esta definición puede ir en cualquier archivo de LookML del proyecto, como un archivo de modelo, un archivo de vista o en su propio archivo de LookML dedicado. Consulta la sección Cómo usar los perfeccionamientos en tu proyecto de LookML para saber cómo funciona.

La definición más precisa combinada con el LookML original tiene el resultado final como si fuera el LookML original de 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 Empresa de transporte aéreo, tal como si la hubieras agregado al archivo de vista original.

Consulta la sección Ejemplo para obtener información más detallada sobre la implementación.

Refinamientos en comparación con extensiones

Looker también admite la extensión de objetos de LookML. La extensión es útil cuando deseas crear una copia nueva de una vista o Explorar existente 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. Luego, se pueden modificar estas vistas nuevas para ocultar ciertos campos en la vista base o para cambiar las definiciones o etiquetas de los campos de la vista base.

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

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

Los desarrolladores avanzados de LookML pueden usar el parámetro extends dentro de una definición de LookML. Consulta la sección Los refinamientos pueden contener extensiones en esta página para obtener más información.

Los refinamientos 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, hay una definición más precisa de 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, los perfeccionamientos son aditivos en lugar de anular. Para obtener más información, consulta la sección Algunos parámetros son aditivos de esta página.

Algunos parámetros son aditivos.

En muchos casos, si la definición contiene el mismo parámetro que el objeto que se define, la definición anulará los valores del parámetro del objeto definido.

Sin embargo, los perfeccionamientos pueden ser aditivos para algunos parámetros, lo que significa que los valores del objeto base se usan junto con los valores del objeto refinado.

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

Y aquí hay una mejor definición de la vista carriers, con una dimensión name que tiene diferentes valores 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 refinada, 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 usar las definiciones mejor en muchas formas creativas. Pero esto también significa que los desarrolladores deben tener mucho cuidado con el 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. Los perfeccionamientos de los archivos incluidos por último anularán los perfeccionamientos de los archivos incluidos antes.
  • Dentro de un solo archivo, las mejoras se aplican línea por línea de abajo hacia arriba. Los perfeccionamientos con el número de línea más alto se aplican al final y anularán cualquier perfeccionamiento anterior, si hay conflictos.

Por ejemplo, en el siguiente archivo de vista, hay dos refinamiento de la vista faa_flights. La primera definición oculta una dimensión (hidden: yes) y la segunda muestra la dimensión (hidden: no). Cuando hay conflictos como este, la definición más abajo en el archivo tiene prioridad: 

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: los perfeccionamientos en el último archivo que se incluye tendrán prioridad. Por ejemplo, si un archivo de modelo incluye los siguientes archivos:

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

Primero, se aplicarán los refinamientos en distance_analysis.lkml y, luego, los refinamientos en el archivo finishing_touches.lkml. Si hay algún conflicto, tendrán prioridad las mejoras del último archivo, finishing_touches.lkml.

Usa final: yes para evitar más refinamientos

Como se describió anteriormente, el mismo objeto se puede definir mejor varias veces en varios lugares, y la última definición anula todas las anteriores.

Si tienes una definición que deseas que se considere la definición final para la vista o Explorar, puedes agregar la marca final: yes a la definición. El IDE de Looker mostrará un error de LookML si hay refinamientos existentes que se aplicarían después de este último criterio de definición o si un desarrollador intenta agregar un nuevo criterio de definición que se aplicaría después de este último. Por ejemplo, la segunda definición en este archivo de vista crearía un error de LookML porque la definición 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 definición es una buena manera de verificar que tus definiciones se apliquen en el orden que deseas.

Los perfeccionamientos pueden contener extensiones.

Los desarrolladores avanzados de LookML pueden usar un parámetro extends dentro de una definición de LookML, que agrega el objeto extendido al objeto que se define.

Para resumir el comportamiento de extends y las mejoras, ten en cuenta lo siguiente:

  • Cuando se extiende un objeto, se crea una copia nueva del objeto y, luego, se basa en é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 vistas nuevas incorporará una copia de la vista base y, desde allí, un desarrollador puede agregar diferentes campos, filtros y otras propiedades para modificar lo que se encuentra en la vista base. La idea es que comiences con un objeto base y, luego, lo uses de diferentes maneras en varios otros objetos. (Puedes consultar la página de documentación Cómo volver a usar código con extends para obtener una explicación completa sobre cómo trabajar con extends).
  • La definición de un objeto agrega una capa de modificaciones al objeto, pero, a diferencia de la extensión, no crea varias copias del objeto. La idea es crear un objeto base sin modificar su LookML original.

Como ejemplo del uso estándar de los refinamientos, aquí se muestra una exploración llamada orders y la exploración +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 una definición más precisa que incluya un extends. A partir del ejemplo, aquí se muestra la misma función orders Explorar. Pero, además, hay una Búsqueda básica llamada users_base, y ahora la definición +orders tiene un parámetro extends que incluye 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 aquí es que la definición +orders tiene un extends dentro. El resultado es que la vista +orders ahora extenderá la exploración users_base.

Cómo Looker implementa extends dentro de las mejoras

Extender un objeto dentro de una definición es un concepto avanzado de LookML. Antes de usar extends en una definición más precisa, debes comprender en detalle lo siguiente:

  • Cómo implementa Looker extends: Si un elemento de LookML se define en el objeto extendido y en el objeto que extiende, se usa la versión del objeto que extiende, a menos que el parámetro sea aditivo. Consulta la página de documentación Cómo volver a usar código con extends para obtener más información.
  • Cómo implementa Looker las mejoras: Si un elemento de LookML se define en varias mejoras, la última mejora anula las anteriores. Para obtener más información, consulta la sección Los refinamientos se aplican en orden en esta página.

Por último, debes comprender cómo Looker combina estos principios para implementar extends que se usa en las definiciones más precisas. Este es el orden que implementa Looker, en el que cada paso anula el anterior en caso de conflictos:

  1. Valores del extends especificado en el objeto
  2. Valores del extends especificados en las definiciones más precisas del objeto
  3. Valores del objeto
  4. Valores de las definiciones más precisas del objeto

A modo de ejemplo, este 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 orders en este ejemplo:

  1. Valores del extends especificado en el objeto. Como la exploración orders tiene un parámetro extends, Looker comienza con los elementos de LookML del objeto que se extiende, que en este caso es la exploración orders_base. En este punto, el valor de label es "Base de pedidos".
  2. Valores de extends especificados en las definiciones más precisas del objeto. Dado que orders tiene una definición más precisa y esta tiene un parámetro extends, Looker aplica elementos de LookML de la extensión de la definición más precisa, que en este caso es users_base Explorar. 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 orders Explorar. Si hay algún conflicto, prevalece el objeto extendido. Por lo tanto, el valor de label es “Orders”.
  4. Valores de las definiciones más precisas del objeto. Por último, Looker aplica elementos de cualquier perfeccionamiento de la exploración orders. Si hay algún conflicto, prevalece el objeto de refinamiento. Por lo tanto, el valor de label es "Orders Refined".

Las mejoras extends son acumulativas

Como se describe en la sección Parámetros de anulación de los perfeccionamientos de esta página, los perfeccionamientos suelen anular la configuración original de un objeto. Este no es el caso del parámetro extends. Cuando se usa extends en una definición más precisa, el valor del parámetro extends se agrega a la lista de elementos extendidos en el objeto original o en las definiciones más precisas anteriores, si las hay. Luego, si hay algún conflicto, se le otorga prioridad al último elemento de la cadena de extensiones.

Por ejemplo, aquí hay una función Explorar base llamada orders_base y una función Explorar orders que extiende la base. Además, hay una exploración de users_base y la definición +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 el orders_base y, luego, las definiciones más precisas de +orders agregan el users_base a la lista extends. El resultado es que la exploración de +orders ahora extenderá orders_base y users_base, como si este fuera el LookML original para la exploración:

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

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

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

Una última cosa a tener en cuenta: en este ejemplo, no importa el orden de los parámetros explore. Sin embargo, en los casos con varias definiciones más precisas del mismo objeto, el orden de las definiciones más precisas sí importa. Como se describe en la sección Los refinamientos se aplican en orden de esta página, el último perfeccionamiento de un archivo anula los anteriores.

Cómo usar los perfeccionamientos en tu proyecto de LookML

Estos son los 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 alojar tus mejoras. Puedes agregar refinamientos en cualquier archivo de LookML existente o crear archivos de LookML independientes para tus refinamientos. (consulta el procedimiento para crear un archivo de prueba de datos en la página de documentación Información sobre otros archivos de proyecto para ver un ejemplo de cómo crear archivos de LookML genéricos).
  3. Usa el parámetro include para incorporar tus mejoras en el modelo:
    • En el archivo en el que escribes tus mejoras, debes incluir los archivos de LookML que deseas definir mejor. El IDE de Looker te dará advertencias si intentas definir mejor un objeto que no está incluido.
    • En el archivo de tu modelo, incluye los archivos en los que se definen tus refinamientos. Puedes combinar archivos y usar incorporaciones de formas muy creativas. Para obtener más información, consulta la sección Cómo usar las mejoras para agregar capas a tu modelo en esta página.

Ejemplo

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

Este es el código LookML de la exploración 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 Explore. En el proyecto e_faa_refined, puedes usar un perfeccionamiento para simplificar en gran medida la exploración de aircraft.

Como aircraft Explore es un archivo importado, no puedes editarlo directamente. En su lugar, puedes agregarle una mejor definición. A continuación, se muestra un ejemplo de un archivo independiente 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 Importa archivos de otros proyectos para obtener detalles sobre cómo hacer referencia a los archivos de proyectos importados).
  • Mejoras en la función Explorar de aircraft:
    • El signo + que aparece antes del nombre de la Búsqueda indica que se trata de una mejora de una Búsqueda existente.
    • El parámetro label cambia la etiqueta de Explorar a "Aeronaves simplificadas".
    • El parámetro fields especifica que solo se mostrarán tres campos en la pestaña Explorar.

El resultado final es como si fuera la vista original de aircraft Explorar y 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
  }
}

Para ver un ejemplo del uso de refinamiento para personalizar una sola vista para varios casos de uso, consulta la receta del libro de recetas Maximiza la reutilización de código con DRY LookML: Personaliza una sola vista base para varios casos de uso.

Otros casos de uso para definir mejor

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

Sin embargo, una vez que tengas la idea de agregar mejoras y, luego, incluirlas en tus modelos, podrás hacer cosas muy interesantes con tus proyectos, como se describe en los siguientes ejemplos.

Usa los perfeccionamientos para agregar análisis

Puedes usar los perfeccionamientos para agregar análisis a tu modelo sin modificar 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 de tu base de datos y se almacenan en un archivo LookML llamado faa_basic.lkml, puedes crear un archivo faa_analysis.lkml en el que uses los perfeccionamientos 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 muestran las mejoras de la función flights Explorar existente del archivo faa_basic.lkml que une la tabla derivada distance_stats en la función flights Explorar. Además, en la parte inferior del ejemplo, se define mejor la vista flights existente para agregar campos nuevos 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]
  }
}

Usa los perfeccionamientos para agregar capas a tu modelo

Otro caso de uso interesante para definir mejor los detalles 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 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 dimensiones para cada columna de la base de datos.

Además del archivo sin procesar, puedes crear un archivo faa_basic.lkml para agregar una nueva capa con refinamientos básicos, como agregar uniones a tus Exploraciones o medidas 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 agregar una capa nueva con análisis (consulta la subsección Cómo usar los refinamientos 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 del modelo. También puedes usar el archivo de modelo para agregar detalles que dirijan tus vistas a las tablas de la base de datos a las que deseas 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 dirigirlo a diferentes tablas de bases de datos, o bien puedes incluir diferentes archivos de perfeccionamiento que creaste para definir otras capas que deseas en tu modelo.

Usa definiciones más precisas para los PDT

Como se describe en la sección Refinamientos en comparación con las extensiones de esta página, una extensión crea una copia nueva del objeto que se extiende. 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 mejorías a la vista del PDT, ya que las mejoras no crean una copia nueva del objeto que se está mejorando.

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 si hay algún perfeccionamiento en el objeto. Consulta la página de documentación Metadatos de objetos de LookML para obtener 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 deseas definir mejor un objeto y, luego, definir etiquetas o descripciones nuevas, 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 Cómo localizar tu modelo de LookML para obtener más información.