incluir

Uso


include: "/views/airports.view"
Jerarquía
include

-o-

include

-o-

include
Valor predeterminado
Ninguno

Acepta
Cadena que contiene un nombre de archivo o un patrón

Definición

El parámetro include especifica los archivos de LookML que estarán disponibles para un modelo, una vista o una exploración. Si deseas usar o hacer referencia a un archivo de LookML dentro de otro archivo, debes agregarlo con el parámetro include.

Puedes usar el parámetro include en los archivos de modelo, los archivos de vista y los archivos de Exploración. El parámetro include puede hacer referencia a diferentes tipos de archivos LookML, según el contexto.

En un archivo de modelo, puedes usar include para hacer referencia a estos tipos de archivos:

En un archivo de vista, puedes usar include para hacer referencia a estos tipos de archivos:

En un archivo de Explore, puedes usar include para hacer referencia a los siguientes tipos de archivos:

También puedes usar include para importar archivos de otros proyectos. Consulta la página de documentación Importación de archivos de otros proyectos para obtener información sobre cómo incluir archivos de otro proyecto.

Ten en cuenta lo siguiente cuando uses include:

  • No es necesario que uses include para los tipos de archivos que no son de LookML, como los archivos de documentación o los archivos de datos.
  • La inclusión de archivos es un proceso de todo o nada, por lo que toda la información del archivo incluido se agrega al archivo incluyente.
  • Puedes usar varios parámetros include en un archivo.
  • Puedes usar el carácter comodín * para indicar archivos con convenciones de nomenclatura estratégicas o con la misma extensión. Por ejemplo, puedes usar "*base.dashboard" para hacer coincidir e incluir "database.dashboard" y "crunchbase.dashboard". Puedes usar "*.dashboard" para indicar todos los archivos con la extensión .dashboard.
  • Puedes usar el carácter comodín * para incluir todos los archivos de un directorio. Por ejemplo, puedes incluir todos los archivos de vista en el directorio views/users/ especificando include: "/views/users/*.view". Consulta la página de documentación sobre carpetas del IDE para obtener más información sobre el uso de comodines con carpetas del IDE.

Usa include en un archivo de modelo

Puedes usar el parámetro include en un archivo de modelo para incluir vistas y paneles o Explores.

Cómo incluir vistas y paneles en un modelo

Usa el parámetro include en un archivo de modelo para especificar los archivos de panel y vista que estarán disponibles para ese modelo. Si deseas usar un archivo de LookML o hacer referencia a él dentro de un modelo, debes agregarlo con el parámetro include.

En el parámetro include, usa la extensión .view para los archivos de vista y la extensión .dashboard para los paneles. Puedes omitir la parte de .lkml y .lookml de estas extensiones.

Puedes usar el carácter comodín * para indicar archivos con convenciones de nomenclatura estratégicas o con la misma extensión. También puedes usar el comodín * en combinación con rutas de acceso a directorios para especificar varios archivos, como se describe en la sección Ejemplos de comodines de la página del parámetro include.

Por ejemplo, podrías usar estos parámetros de include en un archivo de modelo:

include: "/**/*.dashboard"
include: "/*/*base.view.lkml"
include: "//e_commerce/views/*.view.lkml"

Estos parámetros incluirían los siguientes archivos:

  • Todos los archivos del panel en cualquier directorio de tu proyecto
  • Cualquier archivo de vista que termine con base.view.lkml en cualquier directorio secundario inmediato del proyecto, como /views/database.view.lkml o /public/crunchbase.view.lkml
  • Todos los archivos de vista en el directorio /views/ del proyecto importado llamado e_commerce

Si tu proyecto tiene una gran cantidad de archivos de vistas o si usa tablas derivadas persistentes (PDT), debes evitar incluir todos los archivos de vistas en tu modelo. En cambio, incluye archivos de vistas individuales de esta manera. A continuación, se muestra un ejemplo de cómo incluir archivos de vistas individuales y todos los paneles en un proyecto:

include: "/views/order.view"
include: "/views/user.view"
include: "/**/*.dashboard"

Cómo incluir modelos en un modelo

No puedes incluir un archivo de modelo de otro proyecto. En cambio, para reutilizar, refinar o extender exploraciones en varios proyectos, en el proyecto importado, puedes crear un archivo de exploración independiente y, luego, incluir ese archivo de exploración en otros proyectos. Consulta Cómo incluir Explorar en un modelo para obtener más información.

Cómo incluir exploraciones en un modelo

Por lo general, las exploraciones se definen dentro de un archivo de modelo. Sin embargo, a veces necesitas un archivo Explore independiente para una tabla derivada, o bien extender o refinar un Explore en varios modelos.

Si tienes un archivo de exploración independiente, debes usar el parámetro include en el archivo del modelo para incluirlo. En el parámetro include, usa la extensión .explore.lkml para los archivos de Explorar.

El siguiente ejemplo es un archivo de modelo que tiene dos Explorar:

  • La aircraft_new Explorar, que se define en su propio archivo llamado aircraft_new.explore.lkml en la carpeta explores Como esa exploración se define en su propio archivo, debes especificar la ruta de acceso del archivo de exploración en un parámetro include.
  • La exploración accidents, que se define dentro del archivo de modelo Como se define en el propio archivo del modelo, no es necesario que uses un parámetro include para él en el modelo. Sin embargo, sí necesitas un include para la vista en la que se basa la exploración de accidents.
connection: "faa"

include: "/explores/aircraft_new.explore.lkml"
include: "/views/accidents.view"

explore: accidents {
  view_name: accidents
  from: accidents
}

Cómo incluir pruebas de datos en un modelo

Las pruebas de datos se pueden definir directamente en un archivo de modelo o en un archivo de vista. Sin embargo, también puedes crear un archivo de prueba de datos independiente si deseas reutilizar tus pruebas de datos en varios lugares de tu proyecto.

Si tienes un archivo de prueba de datos independiente, debes usar el parámetro include en tu archivo de modelo o archivo de vista para poder ejecutar las pruebas de datos. En el parámetro include, usa la extensión .lkml para los archivos de prueba de datos.

Por ejemplo, aquí se muestra un fragmento de un archivo de modelo que incluye un archivo de prueba de datos:

connection: "faa"

include: "/explores/aircraft_new.explore.lkml"
include: "/views/accidents.view"
include: "/tests/data_tests.lkml"

. . .

Una vez que incluyas el archivo de prueba de datos en un archivo de modelo, podrás ejecutar la prueba de datos para verificar que funcione correctamente y ver si la lógica del modelo pasa la prueba.

También puedes incluir el archivo de prueba de datos en un archivo de vista, como se describe en la secciónCómo incluir pruebas de datos en una vista de esta página.

Cómo usar include en un archivo de vista

En la mayoría de los casos, no necesitas usar include en un archivo de vista. Sin embargo, hay algunos casos en los que sí querrás incluir archivos en tu archivo de vista:

Cómo incluir vistas en una vista (para extenderla o definirla mejor)

También puedes incluir un archivo de vista en otro para extender o refinar la vista incluida.

Por ejemplo, aquí se muestra el archivo de vista marketing_order_fields que incluye el archivo de vista basic_order_fields y, luego, lo extiende:

include: "/views/basic_order_fields.view"
view: marketing_order_fields {
  extends: [basic_order_fields]  # The file that contains the basic_order_fields
}                                # view should be included

Cómo incluir exploraciones en una vista

En la mayoría de los casos, no es necesario que incluyas un Explore en una vista. Sin embargo, las tablas derivadas nativas son un caso especial porque se definen en su propio archivo de vista que tiene un parámetro explore_source. Usas el parámetro explore_source para especificar una exploración y definir las columnas deseadas y otras características deseadas para la tabla derivada nativa. Por lo general, las exploraciones se definen dentro de un archivo de modelo, pero, en el caso de las tablas derivadas nativas, puede ser más claro crear un archivo separado para la exploración con la extensión de archivo .explore.lkml. Si creas un archivo de exploración independiente, debes incluirlo en el archivo de vista de la tabla derivada nativa.

A continuación, se muestra un ejemplo del uso de include en un archivo de vista de tabla derivada nativa para apuntar a un archivo de Exploración:

include: "/explores/order_items.explore.lkml"

view: user_order_facts {
  derived_table: {
    explore_source: order_items {
      column: user_id {field: order_items.user_id}
      column: lifetime_number_of_orders {field: order_items.order_count}
      column: lifetime_customer_value {field: order_items.total_revenue}
      derived_column: average_customer_order {
        sql:  lifetime_customer_value / lifetime_number_of_orders ;;
      }
    }
  }
  dimension: user_id {hidden: yes}
  dimension: lifetime_number_of_orders {type: number}
  dimension: lifetime_customer_value {type: number}
  dimension: average_customer_order {type: number}
}

Consulta nuestra documentación sobre cómo usar sentencias include para habilitar la referencia a campos si deseas obtener más información sobre los archivos de Explore para las tablas derivadas nativas.

Cómo incluir pruebas de datos en una vista

Las pruebas de datos se pueden definir directamente en un archivo de modelo o en un archivo de vista. Sin embargo, también puedes crear un archivo de prueba de datos independiente si deseas reutilizar tus pruebas de datos en varios lugares de tu proyecto.

Si tienes un archivo de prueba de datos independiente, debes usar el parámetro include en tu archivo de modelo o archivo de vista para poder ejecutar las pruebas de datos. En el parámetro include, usa la extensión .lkml para los archivos de prueba de datos.

Por ejemplo, aquí se muestra un fragmento de un archivo de vista que incluye un archivo de prueba de datos:

include: "/tests/data_tests.lkml"

view: orders {
  sql_table_name: looker.orders ;;

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

. . .

Una vez que incluyas el archivo de prueba de datos en un archivo de vista, podrás ejecutar la prueba de datos para verificar que funcione correctamente y ver si la lógica de la vista pasa la prueba.

También puedes incluir el archivo de prueba de datos en un archivo de modelo, como se describe en la sección Cómo incluir pruebas de datos en un modelo de esta página.

Cómo usar include en un archivo de Explore

Por lo general, las exploraciones se definen dentro de un archivo de modelo. Sin embargo, a veces necesitas un archivo Explore independiente para una tabla derivada, o bien extender o refinar un Explore en varios modelos.

Si tienes un archivo de exploración independiente, puedes usar el parámetro include para incluir vistas o otras exploraciones.

Cómo incluir vistas en una exploración

Si tienes un archivo de exploración independiente, debes incluir todas las vistas que se usen en la exploración. Usa la extensión de archivo .view para los archivos de vista. Puedes omitir la parte .lkml de la extensión del archivo. Este es un ejemplo de un archivo de Explore que incluye las dos vistas que usa:

include: "/views/aircraft.view"
include: "/views/aircraft_types.view"

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

Cómo incluir exploraciones en una exploración

Puedes incluir un archivo de Explore en otro, por ejemplo, cuando extiendes o refinas una exploración. Usa el parámetro include y agrega la extensión de archivo .explore.lkml.

A continuación, se muestra un archivo de exploración de ejemplo que incluye otro archivo de exploración y, luego, extiende la exploración:

include: "/explores/base.explore.lkml"

explore: aircraft_information {
  extends: [aircraft]

Usa include con carpetas del IDE

Cuando organices tus archivos de proyectos de LookML en carpetas, deberás proporcionar las rutas de acceso a los archivos dentro de la instrucción include.

Puedes usar rutas de acceso absolutas o relativas en la instrucción include (consulta la sección Sintaxis de rutas de acceso en esta página para ver ejemplos) y los comodines * y ** para incluir varios archivos a la vez (consulta la sección Ejemplos de comodines en esta página para ver ejemplos).

Por ejemplo, supón que tienes esta estructura de directorio en tu proyecto, con el siguiente contenido de nivel superior de la carpeta views:

  • La carpeta orders, que contiene los archivos de vista order_facts y order_items
  • La carpeta users, que contiene los archivos de vista user_with_age_extension, users y users_extended
  • Los archivos de vista individuales distribution_centers, events, inventory_items y products

Estructura de directorio de muestra con carpetas para Exploraciones, modelos y vistas.

Las siguientes instrucciones incluirán la vista products, la vista order_facts y todas las vistas del directorio /views/users/:

include: "/views/products.view"
include: "/views/orders/order_facts.view"
include: "/views/users/*.view"

Cuando cambies la ruta de un archivo, asegúrate de actualizar todas las instrucciones include de tu proyecto para que coincidan con la nueva ruta del archivo. Es posible que veas advertencias de validación de LookML en tus instrucciones include anteriores si ya no hacen referencia a archivos o rutas de acceso a archivos existentes. Además, es posible que veas errores de validación de LookML para los objetos a los que se hace referencia y que ya no se pueden encontrar porque cambiaron sus rutas de acceso a los archivos.

Sintaxis de la ruta de acceso

Estas son algunas sintaxis de ejemplo que puedes usar para incluir archivos:

Sintaxis Descripción
PATH Es la ruta de acceso relativa que comienza en la ubicación del archivo actual.
./PATH Es la ruta de acceso relativa que comienza en la ubicación del archivo actual. Este ejemplo apunta al mismo archivo que el ejemplo anterior: PATH.
../PATH Es la ruta relativa que comienza en el directorio principal del archivo actual.
/PATH Ruta de acceso absoluta que comienza en la raíz del proyecto actual.
//PROJECT_NAME/PATH Ruta de acceso absoluta que comienza en la raíz de un proyecto importado llamado PROJECT_NAME.

Uso de comodines

En el caso de los proyectos en los que solo se deben administrar unos pocos archivos, puedes enumerar cada archivo en su propio parámetro include, de la siguiente manera:

include: "/dashboards/user_info.dashboard"
include: "/views/users.view"

En el caso de los proyectos con muchos archivos para incluir, puedes reducir la cantidad de parámetros include que necesitas escribir usando comodines para incluir varios archivos a la vez:

El uso de comodines puede ser especialmente útil durante el desarrollo cuando necesitas crear una solución temporal para las advertencias de validación de LookML, en especial cuando organizas un proyecto existente en carpetas del IDE. Sin embargo, ten en cuenta lo siguiente cuando uses comodines en tus instrucciones include:

Usa comodines con carpetas del IDE

Puedes usar comodines en combinación con carpetas del IDE para incluir archivos en un directorio específico de tu proyecto de LookML.

Por ejemplo, esta instrucción include hace referencia a todos los archivos del directorio /explores/ de un proyecto de LookML:

include: "/explores/*"

Usa comodines para tipos de archivos específicos

Puedes usar comodines para hacer referencia a todos los archivos de un tipo específico. Por ejemplo, esta instrucción include hace referencia a todos los archivos de Explorar en un proyecto de LookML:

include: "/**/*.explore.lkml"

Consulta la sección Tipos de archivos en un proyecto de LookML de la página de documentación Acerca de los archivos de proyectos de LookML para obtener una lista de los tipos de archivos de LookML y sus extensiones.

Usa comodines con patrones de nombres estratégicos

También puedes usar comodines con nombres de archivos estratégicos para optimizar aún más tus instrucciones include. Por ejemplo, en lugar de nombrar los archivos de la siguiente manera:

/views/apple.view
/views/banana.view
/views/cherry.view
/views/orange.view
/views/celery.view

Puedes agregar un prefijo o sufijo estratégico a los nombres de tus archivos, como se muestra a continuación:

/views/apple.fruit.view
/views/banana.fruit.view
/views/cherry.fruit.view
/views/orange.fruit.view
/views/celery.vegetable.view

Luego, usa comodines para hacer referencia solo al sufijo .fruit con este include:

include: "/views/*.fruit.view"

Ejemplos de comodines

Estos son algunos ejemplos con comodines (ten en cuenta que puedes reemplazar PATH por las sintaxis de ruta de acceso de la tabla anterior):

Sintaxis Descripción
PATH/*.view Coincidencia de comodines para archivos que terminan en .view en PATH.
PATH/*.view.lkml Coincidencia de comodines para archivos que terminan en .view.lkml en PATH.

Dado que los archivos de vista tienen la extensión .view.lkml, este ejemplo especifica el mismo archivo que el ejemplo anterior, PATH/*.view. La parte .lkml no se muestra en el IDE, ni tampoco es necesaria para las instrucciones include..lkml Sin embargo, puedes usar comodines para aprovechar esta parte común de la extensión del archivo. Consulta la página de documentación Archivos de proyecto de LookML para obtener una lista de las extensiones de archivos de proyecto.
PATH/*.lkml Se encontraron archivos que coinciden con el comodín y que terminan en .lkml en PATH.

Ten en cuenta que varios tipos de archivos comparten .lkml como la parte final de la extensión, como .view.lkml y .model.lkml. La parte .lkml no se muestra en el IDE, ni tampoco es necesaria para las instrucciones include..lkml Sin embargo, puedes usar comodines para aprovechar esta parte común de la extensión del archivo. Consulta la página de documentación Archivos de proyecto de LookML para obtener una lista de las extensiones de archivos de proyecto.
PATH/myfile.* Coincidencia de comodines para archivos llamados myfile con cualquier tipo de extensión en PATH.
PATH/myfile.*.lkml Comodín que coincide con los archivos llamados myfile con cualquier tipo de extensión .lkml en PATH.
PATH/my*file.view Comodín que coincide con los archivos que comienzan con my y terminan con file.view en PATH.
PATH/my*fi*le.view Comodines que coinciden con archivos que comienzan con my, seguidos de algunos caracteres, luego fi, algunos caracteres adicionales y que terminan con le.view en PATH.
PATH/*/myfile.lkml Comodín del nombre de la carpeta (solo coincide con un nivel de anidamiento). Coincide con todos los archivos myfile.lkml en cualquier directorio secundario directo de PATH.
PATH/**/my_file.view Coincidencia recursiva de comodines (coincide con cualquier cantidad de anidación) para todos los archivos llamados my_file.view.lkml en PATH y todos los subdirectorios.
PATH/**/*.view Comodín recursivo que coincide con todos los archivos que terminan en .view.lkml en los subdirectorios de PATH.
PATH/**/my_folder/myfile.view Comodín recursivo que coincide con la subruta /my_folder/myfile.view en cualquier profundidad debajo de PATH.

Ejemplos

Consulta las secciones anteriores para ver ejemplos del uso de include en archivos de modelos, archivos de vistas y archivos de exploración.

Aspectos para tener en cuenta

Incluir todos los archivos de vista puede afectar el rendimiento de la validación de LookML

Si tu proyecto tiene una gran cantidad de archivos de vista y los incluyes todos en tu archivo de modelo, esto puede afectar el rendimiento del Validador de LookML. Dado que el validador de LookML verifica todos los archivos de vista incluidos en el modelo, solo debes incluir los archivos de vista necesarios en el parámetro include del archivo de modelo.

Considera usar convenciones de nomenclatura estratégicas para los archivos de vistas, de modo que se puedan incluir fácilmente grupos de vistas en un modelo (consulta el ejemplo en Uso de comodines con patrones de nomenclatura estratégicos en esta página). También puedes usar carpetas del IDE para organizar tus vistas en carpetas. Luego, puedes usar el comodín * para incluir todas las vistas en una sola carpeta, en lugar de incluir todas las vistas de tu proyecto. Consulta la sección sobre cómo usar include con carpetas de IDE para obtener más información.

Incluir todos los archivos de vista puede sobrecargar el esquema de la base de datos.

En los proyectos que usan tablas derivadas persistentes (PDT), puedes incluir el archivo de vista de la PDT en tu archivo de modelo. Sin embargo, cada archivo de modelo que incluya el archivo de vista del PDT creará una copia del PDT en el esquema de borrador de tu base de datos. Si tienes varios archivos de modelo y los incluyes todos en ellos, es posible que agregues desorden innecesario al esquema de prueba de tu base de datos. Por este motivo, asegúrate de incluir el archivo de vista de un PDT solo en los archivos del modelo en los que se necesite el PDT.