Cómo volver a usar código con extends

Este es un tema avanzado en el que se da por sentado que el lector tiene un conocimiento sólido de LookML.

Descripción general

A medida que tu modelo de LookML aumenta de tamaño y complejidad, se vuelve cada vez más útil reutilizarlo en varios lugares. El parámetro extends te permite volver a usar el código, lo que te ayuda a hacer lo siguiente:

  • Escribe código DRY (no te repitas) para que puedas definir elementos en un solo lugar, lo que hará que tu código sea más coherente y más rápido de editar.
  • Administra diferentes conjuntos de campos para diferentes usuarios
  • Comparte patrones de diseño en diferentes partes de tu proyecto
  • Cómo volver a usar conjuntos de combinaciones, dimensiones o medidas en un proyecto

Para extender un objeto LookML, crea uno nuevo y, luego, agrega el parámetro extends para indicar que el objeto nuevo es una extensión de uno existente. Esto significa que tu proyecto tendrá dos versiones del objeto LookML. Si hay algún conflicto, el objeto que se extiende tendrá prioridad y anulará la configuración del objeto que se extiende. Consulta la sección Detalles de la implementación de extends más adelante en esta página para obtener más información.

Consulta las mejoras de LookML: Extender una vista o una exploración es ideal para situaciones en las que deseas tener varias versiones de la vista o la exploración. Sin embargo, si tu objetivo es simplemente modificar una vista o una exploración sin editar el archivo de LookML que la contiene, te recomendamos que uses un perfeccionamiento. También puedes usar un parámetro extends dentro de una definición más precisa. Consulta la página de documentación de Refinamientos de LookML para obtener más información y casos de uso.

Puedes extender las vistas, las exploraciones y los paneles de LookML:

Los modelos no se pueden extender, y no puedes incluir un archivo de modelo en otro. En cambio, si deseas volver a usar o extender las exploraciones en varios modelos, puedes crear un archivo de exploración independiente y, luego, incluirlo en un archivo de modelo.

Consulta los siguientes ejemplos de cómo extender una exploración y cómo extender un panel de LookML.

Cómo extender una exploración

Este es un ejemplo de cómo extender una exploración:

explore: customer {
  persist_for: "12 hours"
}

explore: transaction {
  extends: [customer]
  persist_for: "5 minutes"
}

En este ejemplo, tenemos una exploración llamada Cliente y creamos una segunda exploración llamada Transacción que la extiende. Todo lo que esté en Cliente, como sus uniones, se incluirá en Transacción. Todo lo que esté en Transacción permanecerá en Transacción.

Sin embargo, observa que hay un conflicto: la exploración Cliente indica que el parámetro de configuración persist_for debe ser de 12 horas, pero la exploración Transacción indica que debe ser de 5 minutos. Para la exploración de transacción, se usará la configuración de persist_for: "5 minutes", ya que reemplaza la configuración de la exploración que extiende.

Cómo extender un panel de LookML

Para extender un panel de LookML, los paneles extendidos y los que se extienden deben incluirse en el archivo del modelo. Si un panel que usa el parámetro extends se incluye en un archivo de modelo sin el panel base que extiende, recibirás un error de validación de LookML que indica que no se puede encontrar el panel base (entre otros errores).

Este es un ejemplo de archivo de panel:

Archivo: faa.dashboard.lookml

- dashboard: faa
  title: FAA Dashboard
  layout: newspaper
  elements:
  - title: Aircraft Location
    name: Aircraft Location
    model: e_faa
    explore: aircraft
    type: looker_map
    fields:
    - aircraft.zip
    - aircraft.count
    sorts:
    - aircraft.count desc
    limit: 500
    query_timezone: America/Los_Angeles
    series_types: {}
    row: 0
    col: 0
    width: 8
    height: 6

Podemos crear un nuevo archivo de panel de LookML y extender el panel de FAA agregando una tarjeta nueva:

Archivo: faa_additional.dashboard.lookml

- dashboard: faa_additional
  title: FAA Additional
  extends: faa
  elements:
  - title: Elevation Count
    name: Elevation Count
    model: e_faa
    explore: airports
    type: looker_scatter
    fields:
    - airports.elevation
    - airports.count
    sorts:
    - airports.count desc
    limit: 500
    query_timezone: America/Los_Angeles
    row: 0
    col: 8
    width: 8
    height: 6

Debido a que extiende el panel FAA, el panel FAA Additional incluirá todas las tarjetas que se definan en el archivo faa.dashboard.lookml. Además, el panel FAA Additional tendrá todas las tarjetas que se definan en su propio archivo faa_additional.dashboard.lookml.

La forma más fácil de crear un panel de LookML es obtener el código de LookML de un panel definido por el usuario. También puedes usar esta técnica para obtener el código LookML de tarjetas de panel individuales. Si usas este método, asegúrate de que las posiciones de las tarjetas no se superpongan. En los ejemplos de faa.dashboard.lookml y faa_additional.dashboard.lookml, las tarjetas se encuentran en la fila superior del panel, que se indica con row: 0:

Archivo: faa.dashboard.lookml


    row: 0
    col: 0
    width: 8
    height: 6

Sin embargo, la tarjeta nueva que agregamos al panel FAA Additional está en col: 8, por lo que se muestra junto a la tarjeta del panel extendido:

Archivo: faa_additional.dashboard.lookml


    row: 0
    col: 8
    width: 8
    height: 6

Esto es fácil de pasar por alto, ya que estos elementos se encuentran en diferentes archivos del panel. Por lo tanto, si agregas tarjetas a un panel extendido, asegúrate de verificar si hay conflictos de posicionamiento entre las tarjetas del panel extendido y las del panel de extensión.

Extensión requerida

Puedes usar el parámetro extension: required para marcar un objeto LookML como que requiere una extensión, lo que significa que el objeto no se puede usar por sí solo. Los usuarios no pueden ver un objeto con extension: required por sí solo. Su propósito es actuar solo como punto de partida para que otro objeto de LookML lo extienda. El parámetro extension es compatible con Exploraciones, vistas y paneles de LookML.

Un explore con extension: required no se puede usar como explore_source para una prueba de datos. El validador de LookML generará un error que indica que no se puede encontrar el explore_source.

Usa metadatos para ver las extensiones 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 extensiones del objeto o para ver qué objeto extiende. Consulta la página de documentación Metadatos de objetos de LookML para obtener información.

Detalles de la implementación de extends

Estos son los pasos que sigue Looker cuando extiende un objeto de LookML:

  1. Copia el objeto que se extiende: Looker crea una copia del código de LookML para la vista, Explorar o el panel de LookML que se extiende. Esta nueva copia es el objeto extendido.
  2. Combina el LookML de las dos copias: Looker combina el LookML del objeto extendido en el objeto extendido.
  3. Cómo resolver conflictos entre las copias: En general, 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. Sin embargo, en otros casos, las extensiones combinarán los valores de los parámetros en lugar de anularlos. Consulta la sección Combinación de parámetros en esta página para obtener información.
  4. Aplica el código LookML: Una vez que se resuelven todos los conflictos, Looker interpreta el código LookML resultante con la lógica estándar. En otras palabras, Looker usará todos los valores predeterminados y las suposiciones estándar como con cualquier otra vista, Explorar o panel de LookML.

En las siguientes secciones, se muestran los detalles de estos pasos y se extiende una vista como ejemplo. Este es el código LookML de nuestra vista base, la vista User:

view: user {
  suggestions: yes

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

  }
  dimension: status {
    sql: ${TABLE}.status ;;
    type: number
  }
}

Este es el código LookML de la vista Usuario con extensiones de edad, que extiende la vista Usuario:

include: "/views/user.view"

view: user_with_age_extensions {
  extends: [user]
  suggestions: no

  dimension: age {
    type: number
    sql: ${TABLE}.age ;;
  }

  dimension: status {
    type: string
  }
}

Paso 1: Copia el código de LookML

En este caso, la vista user se extiende a la vista user_with_age_extensions. Como user es la vista que se extiende, se crea una copia antes de la combinación. No es importante saber que se crea una copia. Lo importante es que la vista user original no se modifica y se puede usar como de costumbre.

Paso 2: Combina las copias

El siguiente paso es que todo el LookML de la vista extendida (user) se combine en la vista extendible (user_with_age_extensions). Es importante comprender la naturaleza de esta combinación, que es simplemente una combinación de objetos LookML. En términos prácticos, esto significa que se combinará cualquier LookML escrito de forma explícita, pero los valores predeterminados de LookML que no hayas escrito no se combinarán. En cierto sentido, solo se está compilando el texto de LookML, y no se tiene en cuenta el significado de ese texto.

Paso 3: Resuelve los conflictos

El tercer paso es resolver cualquier conflicto entre las vistas combinadas.

En general, 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. Sin embargo, en otros casos, las extensiones combinarán los valores de los parámetros en lugar de anularlos. Consulta la sección Combinación de parámetros en esta página para obtener información.

En el caso del ejemplo de user_with_age_extensions, ninguno de los parámetros es aditivo y no se especifican opciones de lista ni palabras clave sql especiales, por lo que los valores de los parámetros en la vista de extensión anularán los valores de los parámetros en la vista extendida:

  • El nombre de la vista extendida (user_with_age_extensions) anula el nombre de la vista extendida (user).
  • El valor de extend para suggestions: no anula el valor de extend suggestions: yes.
  • La vista extendida tiene una dimensión llamada age, que no existe en la vista extendida (no hay conflicto).
  • La vista extendida tiene una dimensión llamada name, que no existe en la vista extendible (no hay conflicto).
  • El valor type: string de la dimensión status en la vista extendida anula el valor type: number en la vista extendida.
  • La dimensión status tiene un parámetro sql, que no existe en la vista extendida (no hay conflictos).

El hecho de que aún no se tengan en cuenta los valores predeterminados de LookML es importante, ya que no quieres cometer el error de pensar que se están resolviendo los conflictos entre los valores predeterminados. En realidad, solo se ignoran en este paso. Por eso, debemos agregar parámetros adicionales de forma explícita cuando extendemos objetos:

En este ejemplo en particular, no agregamos sql_table_name a la vista Usuario, lo que causará algunos problemas en el siguiente paso.

Paso 4: Interpreta LookML como de costumbre

En el paso final, el LookML resultante se interpreta como de costumbre, incluidos todos los valores predeterminados. En este ejemplo en particular, el LookML de la vista resultante se interpretaría de la siguiente manera:

include: "/views/user.view"

view: user_with_age_extensions {
  suggestions: no

  dimension: age {
    type: number
    sql: ${TABLE}.age ;;
  }

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

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

Observa que el LookML resultante incluye view: user_with_age_extensions, pero no el parámetro sql_table_name. Como resultado, Looker supondrá que el valor de sql_table_name es igual al nombre de la vista.

El problema es que probablemente no haya una tabla en nuestra base de datos llamada user_with_age_extensions. Por eso, debemos agregar un parámetro sql_table_name a cualquier vista que se vaya a extender. Agregar view_name y view_label a las exploraciones que se extenderán evita problemas similares.

Combinación de extensiones

Existen algunas formas de aprovechar los objetos de LookML con extensiones:

Para ver un ejemplo de un caso de uso avanzado y leer sugerencias para solucionar problemas, consulta la página de prácticas recomendadas Cómo solucionar problemas de un ejemplo de un caso de uso avanzado de extends.

Cómo extender más de un objeto al mismo tiempo

Es posible extender más de un panel, vista o Explorar al mismo tiempo. Por ejemplo:

explore: orders {
  extends: [user_info, marketing_info]
}
# Also works for dashboards and views

El proceso de extensión funciona exactamente como se describe en el ejemplo de implementación, pero hay una regla adicional sobre cómo se resuelven los conflictos. Si hay conflictos entre los varios elementos que se enumeran en el parámetro extends, se les da prioridad a los elementos que se enumeran por último. Por lo tanto, en el ejemplo anterior, si hubiera conflictos entre user_info y marketing_info, prevalecería la exploración de marketing_info.

Cómo encadenar varios extends

También puedes encadenar tantas extensiones como desees. Por ejemplo:

explore: orders {
  extends: [user_info]
  ...
}
explore: user_info {
  extends: [marketing_info]
  ...
}

Una vez más, el proceso de extensión funciona exactamente como se describe en el ejemplo de implementación, con una regla adicional sobre la resolución de conflictos. Si hay algún conflicto, se le otorga prioridad al último elemento de la cadena de extensiones. En este ejemplo:

  • orders tendría prioridad sobre user_info y marketing_info.
  • user_info tendría prioridad sobre marketing_info.

Combinación de parámetros

En general, 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. Este fue el caso en el ejemplo de implementación de esta página.

Sin embargo, en los siguientes casos, las extensiones combinarán los valores de los parámetros en lugar de anularlos:

Algunos parámetros son aditivos.

En muchos casos, si el objeto que extiende contiene el mismo parámetro que el objeto que se extiende, los valores del objeto que extiende anularán los valores del parámetro del objeto extendido. Sin embargo, las extensiones pueden ser aditivas para algunos parámetros, lo que significa que los valores del objeto que se extiende se usan junto con los valores del objeto extendido.

Los siguientes parámetros son aditivos:

En el siguiente ejemplo, la vista carriers 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 esta es la vista carriers_extended, que extiende la vista carriers. La vista carriers_extended también tiene una dimensión name con diferentes parámetros de configuración en el parámetro link:


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

view: carriers_extended {
  extends: [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_extended, los dos parámetros link son aditivos, por lo que la dimensión name mostrará ambos vínculos.

Opciones adicionales con listas

Cuando trabajas con listas, puedes combinarlas, en lugar de que la lista del objeto de extensión sea la ganadora. Considera esta extensión simple con una lista en conflicto llamada animals:

view: pets {
  extends: fish
  set: animals {
    fields: [dog, cat]
  }
}
view: fish {
  set: animals {
    fields: [goldfish, guppy]
  }
}

En este caso, la vista pets realiza la extensión y, por lo tanto, ganará, lo que hará que animals contenga [dog, cat]. Sin embargo, si usas el conjunto especial de EXTENDED*, puedes combinar las listas:

view: pets {
  extends: fish
  set: animals {
    fields: [dog, cat, EXTENDED*]
  }
}
view: fish {
  set: animals {
    fields: [goldfish, guppy]
  }
}

Ahora, la lista animals contendrá [dog, cat, goldfish, guppy].

Combinación en lugar de reemplazo durante la resolución de conflictos

En general, si hay algún conflicto durante la extensión, el objeto que se extiende prevalece. Por ejemplo, considera esta extensión simple:

view: product_short_descriptions {
  extends: products
  dimension: description {
    sql: ${TABLE}.short_description ;;
  }
}
view: products {
  dimension: description {
    sql: ${TABLE}.full_description ;;
  }
}

Puedes ver que hay un conflicto del parámetro sql dentro de la dimensión description. Por lo general, la definición de product_short_descriptions simplemente reemplazará la definición de products porque está realizando la extensión.

Sin embargo, también puedes combinar las definiciones si lo deseas. Para ello, usarás la palabra clave ${EXTENDED} de la siguiente manera:

view: product_short_descriptions {
  extends: products
  dimension: description {
    sql: LEFT(${EXTENDED}, 50) ;;
  }
}
view: products {
  dimension: description {
    sql: ${TABLE}.full_description ;;
  }
}

Ahora, el conflicto del parámetro sql se abordará de manera diferente. En lugar de que se elija la definición de product_short_descriptions, se tomará la definición de products y se insertará donde se usa ${EXTENDED}. La definición resultante para description en este caso será: LEFT(${TABLE}.full_description, 50).

Aspectos para tener en cuenta

Proyectos con localización

Cuando extiendan un objeto, tengan en cuenta que las reglas de localización también se aplican a sus extensiones. Si extiendes un objeto y, luego, defines 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.