Organízate con las colecciones
Guarda y clasifica el contenido según tus preferencias.
Estas prácticas recomendadas reflejan las recomendaciones de un equipo multidisciplinar de Lookers experimentados. Estas estadísticas se han obtenido a lo largo de años de experiencia trabajando con clientes de Looker, desde la implementación hasta el éxito a largo plazo. Estas prácticas se han redactado para que funcionen en la mayoría de los casos y para la mayoría de los usuarios, pero debes aplicar tu mejor criterio a la hora de implementarlas.
Optimizar el rendimiento de las consultas
Para asegurarse de que las consultas se crean y se ejecutan de forma óptima en su base de datos, siga estos consejos para el frontend y el backend:
Crea Exploraciones usando combinaciones many_to_one siempre que sea posible. Unir vistas desde el nivel más granular hasta el nivel de detalle más alto (many_to_one) suele ofrecer el mejor rendimiento de las consultas.
Maximiza el almacenamiento en caché para sincronizarlo con tus políticas de ETL siempre que sea posible y así reducir el tráfico de consultas de bases 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 grupos de datos
en Exploraciones mediante el parámetro persist_with. De esta forma, Looker puede integrarse más estrechamente con la canalización de datos backend, por lo que el uso de la caché se puede maximizar sin el riesgo de analizar datos obsoletos. Las políticas de almacenamiento en caché con nombre se pueden aplicar a todo un modelo o a Exploraciones y tablas derivadas persistentes (PDTs) concretas.
Usa PDTs para hacer consultas más rápido. Convierte las Exploraciones con muchas combinaciones complejas o de bajo rendimiento, o las dimensiones con subconsultas o subselecciones, en PDTs para que las vistas se combinen previamente y estén listas antes del tiempo de ejecución.
No combines vistas en Exploraciones con claves principales concatenadas definidas en Looker. En su lugar, únete a los campos base que componen la clave principal concatenada de la vista. También puede volver a crear la vista como una PDT con la clave principal concatenada predefinida en la definición SQL de la tabla, en lugar de en el LookML de la vista.
Aprovecha la herramienta Explicar en Ejecutor de SQL para hacer comparativas. EXPLAIN genera un resumen del plan de ejecución de consultas de su base de datos para una consulta SQL determinada, lo que le permite detectar los componentes de la consulta que se pueden optimizar. Consulta más información en la publicación de la comunidad Cómo optimizar SQL con EXPLAIN.
Declara los índices. Puedes consultar los índices de cada tabla directamente en Looker desde SQL Runner. Para ello, haz clic en el icono de rueda dentada de una tabla y, a continuación, selecciona Mostrar índices.
Las columnas más habituales que pueden beneficiarse de los índices son las fechas importantes y las claves externas. Añadir índices a estas columnas aumentará el rendimiento de casi todas las consultas. Esto también se aplica a las PDTs. Los parámetros de LookML, como indexes, sort keys y distribution, se pueden aplicar correctamente.
Aumenta la memoria, los núcleos y las operaciones de entrada/salida de las bases de datos con hardware insuficiente o recursos aprovisionados necesarios (como AWS) para procesar grandes conjuntos de datos y mejorar el rendimiento de las consultas.
Optimizar el rendimiento del servidor de Looker
También puede tomar medidas para asegurarse de que el servidor y la aplicación de Looker funcionen de forma óptima:
Limita el número de elementos de cada panel de control. No hay una regla precisa para definir el número, ya que el diseño de cada elemento influye en el consumo de memoria en función de varios factores. Sin embargo, los paneles con 25 o más baldosas suelen dar problemas de rendimiento.
Usa la función de actualización automática de los paneles de control de forma estratégica. Si un panel de control 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 dinamismos de forma estratégica y evita usarlos en exceso en los Looks y los baldosas de los paneles de control. Las consultas con dimensiones dinamizadas consumirán más memoria. Cuantas más dimensiones se pivoten, más memoria se consumirá al cargar el contenido (una exploración, un Look o un panel de control).
Usa funciones como combinar resultados, campos personalizados y cálculos de tabla con moderación.
Estas funciones están pensadas para usarse como pruebas de concepto que te ayuden a diseñar tu modelo.
Es una práctica recomendada codificar de forma rígida los cálculos y las funciones que se usan con frecuencia en LookML, lo que generará SQL para que se procese en tu base de datos.
Si se realizan demasiados cálculos, se puede producir una competencia por la memoria Java en la instancia de Looker, lo que hará que la instancia responda más lentamente.
Limita el número de vistas incluidas en un modelo cuando haya un gran número de archivos de vista. Incluir todas las vistas en un solo modelo puede ralentizar el rendimiento. Si hay un gran número de vistas en un proyecto, considere la posibilidad de incluir solo los archivos de vista necesarios en cada modelo. Te recomendamos que utilices convenciones de nomenclatura estratégicas para los nombres de los archivos de vista, de modo que puedas incluir fácilmente grupos de vistas en un modelo. Puede consultar un ejemplo en la documentación del parámetro includes.
Evita devolver un gran número de puntos de datos de forma predeterminada en los baldosines de los paneles de control y en los Looks. Las consultas que devuelvan miles de puntos de datos consumirán más memoria. Aplica
filtros de frontend a los paneles de control, los Looks y las Exploraciones, y a nivel de LookML con los parámetros required filters, conditionally_filter y sql_always_where para limitar los datos siempre que sea posible.
Descarga o envía consultas con la opción Todos los resultados con moderación, ya que algunas consultas pueden ser muy grandes y sobrecargar el servidor de Looker cuando se procesan.
Para obtener más ayuda a la hora de identificar la fuente de los problemas de rendimiento, consulta la página de prácticas recomendadas Resumen de rendimiento.
[[["Es fácil de entender","easyToUnderstand","thumb-up"],["Me ofreció una solución al problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Es difícil de entender","hardToUnderstand","thumb-down"],["La información o el código de muestra no son correctos","incorrectInformationOrSampleCode","thumb-down"],["Me faltan las muestras o la información que necesito","missingTheInformationSamplesINeed","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-08-20 (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."]]