Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Estas prácticas recomendadas reflejan las recomendaciones que comparte un equipo multifuncional de Lookers experimentados. Estas estadísticas provienen de años de experiencia trabajando con clientes de Looker, desde la implementación hasta el éxito a largo plazo. Las prácticas están escritas para funcionar en la mayoría de los casos y situaciones, pero debes usar tu mejor criterio cuando las implementes.
Optimiza el rendimiento de las consultas
Puedes asegurarte de que las consultas se compilen y ejecuten de forma óptima en tu base de datos con las siguientes sugerencias de frontend y backend:
Crea Exploraciones con uniones many_to_one siempre que sea posible. Unir vistas desde el nivel más detallado hasta el más alto (many_to_one) suele proporcionar el mejor rendimiento de las consultas.
Maximiza el almacenamiento en caché para sincronizarlo con tus políticas de ETL siempre que sea posible y reducir el tráfico de consultas de la base de datos. De forma predeterminada, Looker almacena en caché las consultas durante una hora. Puedes controlar la política de almacenamiento en caché y sincronizar las actualizaciones de datos de Looker con tu proceso de ETL aplicando datagroups en Exploraciones con el parámetro persist_with. Esto permite que Looker se integre más estrechamente con la canalización de datos del backend, de modo que se pueda maximizar el uso de la caché sin correr el riesgo de analizar datos inactivos. Las políticas de almacenamiento en caché con nombre se pueden aplicar a un modelo completo o a Exploraciones y tablas derivadas persistentes (PDT) individuales.
Usa PDT para realizar consultas más rápidas. Convierte Exploraciones con muchas combinaciones complejas o de bajo rendimiento, o dimensiones con subconsultas o subselecciones, en PDT para que las vistas estén preunidas y listas antes del tiempo de ejecución.
Evita unir vistas en Explorar en claves primarias concatenadas que se definen en Looker. En su lugar, únete a los campos base que conforman la clave primaria concatenada desde la vista. Como alternativa, vuelve a crear la vista como un PDT con la clave principal concatenada predefinida en la definición de SQL de la tabla, en lugar de en el código LookML de una vista.
Aprovecha la herramienta Explain in SQL Runner para realizar comparativas. EXPLAIN produce una descripción general del plan de ejecución de consultas de tu base de datos para una consulta de SQL determinada, lo que te permite detectar los componentes de la consulta que se pueden optimizar. Obtén más información en la publicación de Comunidad Cómo optimizar SQL con EXPLAIN.
Declara índices. Puedes ver los índices de cada tabla directamente en Looker desde SQL Runner. Para ello, haz clic en el ícono de ajustes de una tabla y, luego, selecciona Mostrar índices.
Las columnas más comunes que pueden beneficiarse de los índices son las fechas importantes y las claves externas. Agregar índices a estas columnas aumentará el rendimiento de casi todas las consultas. Esto también se aplica a los PDT. Los parámetros de LookML, como indexes, sort keys y distribution, se pueden aplicar de manera adecuada.
Aumenta la memoria, los núcleos y la E/S (entrada/salida) de las bases de datos con hardware insuficiente o recursos aprovisionados necesarios (como AWS) para procesar conjuntos de datos grandes y mejorar el rendimiento de las consultas.
Optimiza el rendimiento del servidor de Looker
También puedes tomar medidas para asegurarte de que el servidor y la aplicación de Looker tengan un rendimiento óptimo:
Limita la cantidad de elementos en un panel individual. No hay una regla precisa para definir la cantidad, ya que el diseño de cada elemento afecta el consumo de memoria en función de una variedad de factores. Sin embargo, los paneles con 25 o más tarjetas suelen ser problemáticos en términos de rendimiento.
Usa la función de actualización automática del panel de forma estratégica. Si un panel usa la actualización automática, asegúrate de que no se actualice más rápido que los procesos de ETL que se ejecutan en segundo plano.
Usa los ejes de manera estratégica y evita usarlos en exceso en las tarjetas de los paneles y los aspectos. Las consultas con dimensiones pivotadas consumirán más memoria. Cuanta más dimensiones se pivoten, más memoria se consumirá cuando se cargue el contenido (una exploración, una vista o un panel).
Usa funciones, como combinar resultados, campos personalizados y cálculos basados en tablas, con moderación.
El objetivo de estas funciones es que se usen como pruebas de concepto para ayudarte a diseñar tu modelo.
Se recomienda codificar los cálculos y las funciones que se usan con frecuencia en LookML, lo que generará SQL para procesarse en tu base de datos.
Los cálculos excesivos pueden competir por la memoria de Java en la instancia de Looker, lo que hace que esta responda más lentamente.
Limita la cantidad de vistas incluidas en un modelo cuando hay una gran cantidad de archivos de vista. Si incluyes todas las vistas en un solo modelo, el rendimiento puede disminuir. Cuando hay una gran cantidad de vistas en un proyecto, considera incluir solo los archivos de vista necesarios en cada modelo. Considera usar convenciones de nomenclatura estratégicas para los nombres de los archivos de vista, de modo que puedas incluir fácilmente grupos de vistas dentro de un modelo. En la documentación del parámetro includes, se describe un ejemplo.
Evita mostrar una gran cantidad de datos de forma predeterminada en las tarjetas del panel y los aspectos. Las consultas que muestran miles de datos consumirán más memoria. Asegúrate de que los datos se limiten siempre que sea posible aplicando
filtros del frontend a los paneles, las miradas y las exploraciones, y a nivel de LookML con los parámetros required filters, conditionally_filter y sql_always_where.
Descarga o entrega consultas con la opción Todos los resultados con moderación, ya que algunas pueden ser muy grandes y abrumar al servidor de Looker cuando se procesan.
Para obtener más ayuda para identificar la fuente de los problemas de rendimiento, consulta la página de prácticas recomendadas Descripción general del rendimiento.
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Difícil de entender","hardToUnderstand","thumb-down"],["Información o código de muestra incorrectos","incorrectInformationOrSampleCode","thumb-down"],["Faltan la información o los ejemplos que necesito","missingTheInformationSamplesINeed","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-07-31 (UTC)"],[],[],null,["# Optimize Looker performance\n\n\u003e *These best practices reflect recommendations shared by a cross-functional team of seasoned Lookers. These insights come from years of experience working with Looker customers from implementation to long-term success. The practices are written to work for most users and situations, but you should use your best judgment when implementing.*\n\nOptimize query performance\n--------------------------\n\n\nYou can ensure that queries are built and executed optimally against your database with the following frontend and backend tips:\n\n- Build Explores using [`many_to_one`](/looker/docs/reference/param-explore-join-relationship#many_to_one_(the_default_value)) joins whenever possible. Joining views from the most granular level to the highest level of detail (`many_to_one`) typically provides the best query performance.\n- Maximize caching to sync with your ETL policies wherever possible to reduce database query traffic. By default, Looker caches queries for one hour. You can control the caching policy and sync Looker data refreshes with your ETL process by applying [datagroups](/looker/docs/caching-and-datagroups) within Explores, using the [`persist_with`](/looker/docs/reference/param-explore-persist-with) parameter. This enables Looker to integrate more closely with the backend data pipeline, so cache usage can be maximized without the risk of analyzing stale data. Named caching policies can be applied to an entire model and/or to individual Explores and [persistent derived tables](/looker/docs/caching-and-datagroups#how_looker_uses_pdts_and_rebuilds_them) (PDTs).\n- Use Looker's [aggregate awareness](/looker/docs/aggregate_awareness) functionality to create roll-ups or summary tables that Looker can use for queries whenever possible, especially for common queries of large databases. You can also leverage aggregate awareness to drastically [improve the performance of entire dashboards](/looker/docs/reference/param-explore-aggregate-table#get_lookml_dashboard). See the [Aggregate awareness tutorial](/looker/docs/best-practices/aggregate-awareness-tutorial) for additional information.\n- Use [PDTs](/looker/docs/derived-tables#persistent_derived_table) for faster queries. Convert Explores with many complex or unperformant joins, or dimensions with subqueries or subselects, into PDTs so that the views are pre-joined and ready prior to runtime.\n- If your [database dialect supports incremental PDTs](/looker/docs/incremental-pdts#supported_database_dialects_for_incremental_pdts), configure [incremental PDTs](/looker/docs/incremental-pdts) to reduce the time Looker spends rebuilding PDT tables.\n- Avoid joining views into Explores on concatenated [primary keys](/looker/docs/reference/param-field-primary-key) that are defined in Looker. Instead, join on the base fields that make up the concatenated primary key from the view. Alternatively, recreate the view as a PDT with the concatenated primary key predefined in the table's SQL definition, rather than in a view's LookML.\n- Leverage the [Explain in SQL Runner tool](/looker/docs/sql-runner-manage-db#examining_an_execution_plan_using_explain) for benchmarking. `EXPLAIN` produces an overview of your database's query execution plan for a given SQL query, letting you detect query components that can be optimized. Learn more in the [How to optimize SQL with `EXPLAIN`](https://community.looker.com/technical-tips-tricks-1021/how-to-optimize-sql-with-explain-30772) Community post.\n- Declare indexes. You can look at the indexes of each table directly in Looker from [SQL Runner](/looker/docs/sql-runner-basics) by clicking the gear icon in a table and then selecting [**Show Indexes**](/looker/docs/sql-runner-manage-db#getting_table_information).\n\n \u003cbr /\u003e\n\n The most common columns that can benefit from indexes are important dates and foreign keys. Adding indexes to these columns will increase performance for almost all queries. This also applies for PDTs. LookML parameters, such as [`indexes`](/looker/docs/reference/param-view-indexes), [`sort keys`](/looker/docs/reference/param-view-sortkeys), and [`distribution`](/looker/docs/reference/param-view-distribution), can be applied appropriately.\n- Increase memory, cores, and I/O (input/output) of databases with insufficient hardware or necessary provisioned resources (such as AWS) for processing large datasets, to increase query performance.\n\nOptimize Looker server performance\n----------------------------------\n\n\nYou can also take measures to ensure that the Looker server and application are performing optimally:\n\n- Limit the number of elements within an individual dashboard. There is no precise rule for defining the number, because the design of each element impacts memory consumption based on a variety of factors; however, dashboards with 25 or more tiles tend to be problematic when it comes to performance.\n- Use the [dashboard auto refresh](/looker/docs/editing-user-defined-dashboards#autorefresh) feature strategically. If a dashboard uses auto refresh, make sure it refreshes no faster than the ETL processes running behind the scenes.\n- Use pivots strategically, and avoid over-using pivots within dashboard tiles and Looks. Queries with pivoted dimensions will consume more memory. The more dimensions that are pivoted, the more memory is consumed when content (an Explore, a Look, or a dashboard) is loaded.\n- Use features, such as [merge results](/looker/docs/merged-results), [custom fields](/looker/docs/custom-fields), and [table calculations](/looker/docs/table-calculations), sparingly. These features are intended to be used as proofs of concept to help design your model. It is best practice to hardcode any frequently used calculations and functions in LookML, which will generate SQL to be processed on your database. Excessive calculations can compete for Java memory on the Looker instance, causing the Looker instance to respond more slowly.\n- Limit the number of views included within a model when a large number of view files are present. Including all views in a single model can slow performance. When a large number of views are present within a project, consider including only the view files needed within each model. Consider using strategic naming conventions for view file names, to enable easy inclusion of groups of views within a model. An example is outlined in the [`includes`](/looker/docs/reference/param-model-include#things_to_know) parameter documentation.\n- Avoid returning a large number of data points by default within dashboard tiles and Looks. Queries that return thousands of data points will consume more memory. Ensure that data is limited wherever possible by applying frontend [filters](/looker/docs/filters-user-defined-dashboards#adding_dashboard_filters) to dashboards, Looks and Explores, and on the LookML level with [`required filters`](/looker/docs/filters-user-defined-dashboards#requiring_a_filter_value), [`conditionally_filter`](/looker/docs/reference/param-explore-conditionally-filter) and [`sql_always_where`](/looker/docs/reference/param-explore-sql-always-where) parameters.\n- Download or deliver queries using the [**All Results**](/looker/docs/downloading#all_results) option sparingly, as some queries can be very large and overwhelm the Looker server when processed.\n\n\nFor more help identifying the source of performance issues, check out the [Performance overview](/looker/docs/best-practices/how-to-optimize-looker-performance) Best Practices page."]]