Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
Essas práticas recomendadas refletem as recomendações compartilhadas por uma equipe multidisciplinar de profissionais experientes. Esses insights vêm de anos de experiência trabalhando com clientes do Looker, desde a implementação até o sucesso a longo prazo. As práticas foram criadas para funcionar para a maioria dos usuários e situações, mas você precisa usar seu melhor julgamento ao implementar.
Otimizar a performance da consulta
Você pode garantir que as consultas sejam criadas e executadas de maneira otimizada no seu banco de dados com as seguintes dicas de front-end e back-end:
Crie análises usando mesclagens many_to_one sempre que possível. A mesclagem de visualizações do nível mais granular ao mais detalhado (many_to_one) geralmente oferece a melhor performance de consulta.
Maximize o cache para sincronizar com suas políticas de ETL sempre que possível para reduzir o tráfego de consulta do banco de dados. Por padrão, o Looker armazena em cache as consultas por uma hora. É possível controlar a política de armazenamento em cache e sincronizar as atualizações de dados do Looker com seu processo de ETL aplicando datagroups
nas análises usando o parâmetro persist_with. Isso permite que o Looker se integre mais ao pipeline de dados do back-end, para que o uso do cache possa ser maximizado sem o risco de analisar dados desatualizados. As políticas de armazenamento em cache nomeadas podem ser aplicadas a um modelo inteiro e/ou a análises detalhadas e tabelas derivadas persistentes (PDTs, na sigla em inglês) individuais.
Use PDTs para consultas mais rápidas. Converta análises detalhadas com muitas mesclagens complexas ou sem desempenho ou dimensões com subconsultas ou subseleções em PDTs para que as visualizações sejam mescladas com antecedência e estejam prontas antes do tempo de execução.
Evite mesclar visualizações em análises em chaves primárias concatenadas definidas no Looker. Em vez disso, faça a mesclagem nos campos básicos que compõem a chave primária concatenada da visualização. Como alternativa, recrie a visualização como um PDT com a chave primária concatenada predefinida na definição SQL da tabela, em vez de uma visualização do LookML.
Use a ferramenta Explain in SQL Runner para comparar. O EXPLAIN gera uma visão geral do plano de execução de consulta do banco de dados para uma determinada consulta SQL, permitindo que você detecte componentes de consulta que podem ser otimizados. Saiba mais na postagem da Comunidade Como otimizar o SQL com EXPLAIN.
Declare índices. Para conferir os índices de cada tabela diretamente no Looker do SQL Runner, clique no ícone de engrenagem em uma tabela e selecione Mostrar índices.
As colunas mais comuns que podem se beneficiar de índices são datas importantes e chaves estrangeiras. Adicionar índices a essas colunas aumenta a performance de quase todas as consultas. Isso também se aplica a PDTs. Os parâmetros do LookML, como indexes, sort keys e distribution, podem ser aplicados de maneira adequada.
Aumente a memória, os núcleos e a E/S (entrada/saída) de bancos de dados com hardware insuficiente ou recursos provisionados necessários (como a AWS) para processar grandes conjuntos de dados e aumentar a performance da consulta.
Otimizar a performance do servidor do Looker
Também é possível tomar medidas para garantir que o servidor e o aplicativo do Looker tenham o melhor desempenho possível:
Limite o número de elementos em um painel individual. Não há uma regra precisa para definir o número, porque o design de cada elemento afeta o consumo de memória com base em vários fatores. No entanto, painéis com 25 ou mais blocos tendem a ser problemáticos em relação à performance.
Use o recurso de atualização automática do painel de forma estratégica. Se um painel usa a atualização automática, verifique se ele não é mais rápido do que os processos de ETL em execução em segundo plano.
Use as mudanças de perspectiva de maneira estratégica e evite usá-las demais nos blocos do painel e nos Looks. Consultas com dimensões pivotadas consomem mais memória. Quanto mais dimensões forem pivotadas, mais memória será consumida quando o conteúdo (um recurso "Explorar", "Look" ou um painel) for carregado.
Use recursos como mesclar resultados, campos personalizados e cálculos de tabela com moderação.
Esses recursos são destinados a serem usados como provas de conceito para ajudar a projetar seu modelo.
É recomendável codificar em modo fixo todos os cálculos e funções usados com frequência no LookML, que vai gerar SQL para ser processado no seu banco de dados.
Cálculos excessivos podem competir pela memória Java na instância do Looker, fazendo com que ela responda mais lentamente.
Limite o número de visualizações incluídas em um modelo quando houver um grande número de arquivos de visualização. Incluir todas as visualizações em um único modelo pode diminuir a performance. Quando um grande número de visualizações estiver presente em um projeto, considere incluir apenas os arquivos de visualização necessários em cada modelo. Considere usar convenções de nomenclatura estratégicas para os nomes dos arquivos de visualização, para facilitar a inclusão de grupos de visualizações em um modelo. Um exemplo está descrito na documentação do parâmetro includes.
Evite retornar um grande número de pontos de dados por padrão nos blocos do painel e nos Looks. Consultas que retornam milhares de pontos de dados vão consumir mais memória. Limite os dados sempre que possível aplicando
filtros no front-end a dashboards, Looks e Análises, e no nível da LookML com os parâmetros required filters, conditionally_filter e sql_always_where.
Faça o download ou envie consultas usando a opção Todos os resultados com moderação, porque algumas consultas podem ser muito grandes e sobrecarregar o servidor do Looker quando processadas.
Para mais ajuda na identificação da origem dos problemas de performance, consulte a página de práticas recomendadas Visão geral de desempenho.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Difícil de entender","hardToUnderstand","thumb-down"],["Informações incorretas ou exemplo de código","incorrectInformationOrSampleCode","thumb-down"],["Não contém as informações/amostras de que eu preciso","missingTheInformationSamplesINeed","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 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."]]