As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Dicas de consulta do Gremlin
É possível usar as dicas de consulta para especificar estratégias de otimização e avaliação para uma consulta do Gremlin específica no Amazon Neptune.
Dicas de consulta são especificadas, adicionando uma `withSideEffect` etapa para a consulta com a seguinte sintaxe.
```
g.withSideEffect(hint, value)
```
+ *dica*: identifica o tipo de dica a ser aplicada.
+ *value*: determina o comportamento do aspecto do sistema em consideração.
Por exemplo, veja a seguir como incluir uma dica `repeatMode` em uma travessia Gremlin.
**nota**
Todas os efeitos colaterais de dicas de consulta do Gremlin são prefixados com `Neptune#`.
```
g.withSideEffect('Neptune#repeatMode', 'DFS').V("3").repeat(out()).times(10).limit(1).path()
```
A consulta anterior instrui o mecanismo do Neptune a percorrer o grafo *Profundidade primeiro* (`DFS`) em vez do Neptune padrão, *Amplitude primeiro* (`BFS`).
As seções a seguir fornecem mais informações sobre as dicas de consulta disponíveis e o seu uso.
**Topics**
+ [Dicas de consulta repeatMode do Gremlin](gremlin-query-hints-repeatMode.md)
+ [Dicas de consulta noReordering do Gremlin](gremlin-query-hints-noReordering.md)
+ [Dica de consulta typePromotion do Gremlin](gremlin-query-hints-typePromotion.md)
+ [Dica de consulta useDFE do Gremlin](gremlin-query-hints-useDFE.md)
+ [Dicas de consulta do Gremlin para usar o cache de resultados](gremlin-query-hints-results-cache.md)
# Dicas de consulta repeatMode do Gremlin
A dica de consulta `repeatMode` do Neptune especifica como o mecanismo do Neptune avalia a etapa `repeat()` em um percurso do Gremlin: primeiro em amplitude, primeiro em profundidade, ou profundidade em partes primeiro.
O modo de avaliação da etapa `repeat()` é importante quando ele é usado para encontrar ou seguir um caminho, em vez de simplesmente repetir uma etapa por um número limitado de vezes.
## Sintaxe
A dica de consulta `repeatMode` é especificada, adicionando uma etapa `withSideEffect` para a consulta.
```
g.withSideEffect('Neptune#repeatMode', 'mode').gremlin-traversal
```
**nota**
Todas os efeitos colaterais de dicas de consulta do Gremlin são prefixados com `Neptune#`.
**Modos disponíveis**
+ `BFS`
Pesquisa primeiro em largura
O modo de execução padrão para a `repeat()` etapa. Isso obtém todos os nós irmãos antes de se aprofundar ao longo do caminho.
Esta versão é intensiva em memória e as fronteiras podem ficar muito grandes. Há um risco mais elevado de que a consulta seja executada sem memória e cancelada pelo mecanismo do Neptune. Isso é o que mais se aproxima de outras implementações do Gremlin.
+ `DFS`
Pesquisa primeiro em profundidade
Acompanhe cada caminho até a profundidade máxima antes de prosseguir para a solução seguinte.
Isso usa menos memória. Pode fornecer melhor desempenho em situações como descobrir um único caminho desde um ponto de partida de vários saltos.
+ `CHUNKED_DFS`
Pesquisa primeiro em profundidade em partes
Uma abordagem híbrida que explora o gráfico primeiro em profundidade em partes de 1.000 nós, em vez de 1 nó (`DFS`) ou todos os nós (`BFS)`.
O mecanismo do Neptune receberá até mil nós em cada nível antes de seguir o caminho mais profundo.
Esta é uma abordagem equilibrada entre velocidade e o uso de memória.
Também é útil se você deseja usar o `BFS`, mas a consulta estiver consumindo muita memória.
## Exemplo
A seção a seguir descreve o efeito do modo de repetição em uma travessia do Gremlin.
No Neptune, modo padrão para a etapa `repeat()` é realizar uma estratégia de execução primeiro em amplitude (`BFS`) para todos os percursos.
Na maioria dos casos, a TinkerGraph implementação usa a mesma estratégia de execução, mas em alguns casos ela altera a execução de uma travessia.
Por exemplo, a TinkerGraph implementação modifica a consulta a seguir.
```
g.V("3").repeat(out()).times(10).limit(1).path()
```
A etapa `repeat()` nesta travessia é "desenrolada" na seguinte travessia, que resulta em uma estratégia primeiro em profundidade (`DFS`).
```
g.V().out().out().out().out().out().out().out().out().out().out().limit(1).path()
```
**Importante**
O mecanismo de consulta do Neptune não faz isso automaticamente.
Breadth-first (`BFS`) é a estratégia de execução padrão e é semelhante à da maioria dos TinkerGraph casos. No entanto, existem certos casos em que as estratégias de primeiro em profundidade (`DFS`) são preferíveis.
**BFS (padrão)**
Primeiro em largura (BFS) é a estratégia de execução padrão para o operador `repeat()`.
```
g.V("3").repeat(out()).times(10).limit(1).path()
```
O mecanismo do Neptune explora totalmente as primeiras fronteiras de nove saltos antes de encontrar uma solução para dez saltos. Isso é eficaz em muitos casos, como consultas de caminho mais curto.
No entanto, no caso do exemplo anterior, a travessia seria mais rápida usando o modo primeiro em profundidade (`DFS`) para o operador `repeat()`.
**DFS**
A consulta a seguir usa o modo primeiro em profundidade (`DFS`) para o operador `repeat()`.
```
g.withSideEffect("Neptune#repeatMode", "DFS").V("3").repeat(out()).times(10).limit(1)
```
Isso segue cada solução individual para a profundidade máxima antes de explorar a solução seguinte.
# Dicas de consulta noReordering do Gremlin
Ao enviar um percurso do Gremlin, o mecanismo de consulta do Neptune investiga a estrutura do percurso e reordena partes da consulta, tentando minimizar a quantidade de trabalho necessária para avaliação e tempo de resposta da consulta. Por exemplo, uma travessia com várias restrições, como várias etapas `has()`, normalmente não é avaliada na ordem determinada. Em vez de ser reordenado após a consulta, ele é verificado com análise estática.
O mecanismo de consulta do Neptune tenta identificar qual restrição é mais seletiva e executa essa primeiro. Isso muitas vezes ocasiona melhor desempenho, mas a ordem que o Neptune escolhe para avaliar a consulta pode não ser sempre a ideal.
Se você sabe exatamente as características dos dados e deseja ditar manualmente a ordem de execução da consulta, use a dica de consulta `noReordering` do Neptune para especificar que o percurso deve ser avaliado na ordem indicada.
## Sintaxe
A dica de consulta `noReordering` é especificada, adicionando uma etapa `withSideEffect` para a consulta.
```
g.withSideEffect('Neptune#noReordering', true or false).gremlin-traversal
```
**nota**
Todas os efeitos colaterais de dicas de consulta do Gremlin são prefixados com `Neptune#`.
**Valores disponíveis**
+ `true`
+ `false`
# Dica de consulta typePromotion do Gremlin
Quando você envia um percurso do Gremlin que filtra por um valor ou um intervalo numérico, o mecanismo de consulta do Neptune normalmente deve usar promoção de tipo ao executar a consulta. Isso significa que ele precisa examinar valores de todos os tipos que possam conter o valor que você está filtrando.
Por exemplo, se você estiver filtrando valores iguais a 55, o mecanismo deverá procurar números inteiros iguais a 55, números inteiros longos iguais a 55L, flutuantes iguais a 55,0, etc. Cada promoção de tipo exige uma pesquisa adicional no armazenamento, o que pode fazer com que uma consulta aparentemente simples leve um tempo inesperadamente longo para ser concluída.
Digamos que você esteja pesquisando todos os vértices com uma propriedade de idade do cliente maior que 5:
```
g.V().has('customerAge', gt(5))
```
Para executar esse percurso completamente, o Neptune deve expandir a consulta para examinar cada tipo numérico para o qual o valor que você está consultando poderia ser promovido. Nesse caso, o filtro `gt` deve ser aplicado para qualquer número inteiro acima de 5, qualquer valor longo acima de 5L, qualquer flutuante acima de 5,0 e qualquer dobro acima de 5,0. Como cada um desses tipos de promoção exige uma pesquisa adicional sobre armazenamento, você verá vários filtros por filtro numérico ao executar o [API `profile` do Gremlin](gremlin-profile-api.md) para essa consulta, e ela levará muito mais tempo para ser concluída do que o esperado.
Muitas vezes, a promoção de tipo é desnecessária porque você sabe de antemão que só precisa encontrar valores de um tipo específico. Nesse caso, você pode acelerar suas consultas drasticamente usando a dica de consulta `typePromotion` para desativar a promoção de tipos.
## Sintaxe
A dica de consulta `typePromotion` é especificada, adicionando uma etapa `withSideEffect` para a consulta.
```
g.withSideEffect('Neptune#typePromotion', true or false).gremlin-traversal
```
**nota**
Todas os efeitos colaterais de dicas de consulta do Gremlin são prefixados com `Neptune#`.
**Valores disponíveis**
+ `true`
+ `false`
Para desativar a promoção de tipos para a consulta acima, você usaria:
```
g.withSideEffect('Neptune#typePromotion', false).V().has('customerAge', gt(5))
```
# Dica de consulta useDFE do Gremlin
Use essa dica de consulta para permitir o uso do DFE para executar a consulta. Por padrão, o Neptune não usa o DFE sem que essa dica de consulta esteja definida como `true`, porque o parâmetro de instância [neptune\$1dfe\$1query\$1engine](parameters.md#parameters-instance-parameters-neptune_dfe_query_engine) tem como padrão `viaQueryHint`. Se você definir esse parâmetro de instância como `enabled`, o mecanismo do DFE será usado para todas as consultas, exceto aquelas com a dica de consulta `useDFE` definida como `false`.
Exemplo de habilitação do DFE para uma consulta:
```
g.withSideEffect('Neptune#useDFE', true).V().out()
```
# Dicas de consulta do Gremlin para usar o cache de resultados
As dicas de consulta a seguir podem ser usadas quando o [cache de resultados da consulta](gremlin-results-cache.md) está habilitado.
## Dica de consulta `enableResultCache` do Gremlin
A dica de consulta `enableResultCache` com um valor de `true` fará com que os resultados da consulta sejam gerados do cache se já tiverem sido armazenados em cache. Caso contrário, ela gerará novos resultados e os armazena em cache até que sejam limpos do cache. Por exemplo:
```
g.with('Neptune#enableResultCache', true)
.V().has('genre','drama').in('likes')
```
Posteriormente, é possível acessar os resultados em cache emitindo exatamente a mesma consulta novamente.
Se o valor dessa dica de consulta for `false`, ou se não estiver presente, os resultados da consulta não serão armazenados em cache. No entanto, configurá-lo como `false` não limpa os resultados existentes em cache. Para limpar os resultados em cache, use a dica `invalidateResultCache` ou `invalidateResultCachekey`.
## Dica de consulta `enableResultCacheWithTTL` do Gremlin
A dica de consulta `enableResultCacheWithTTL` também gera resultados em cache, se houver, sem afetar o TTL dos resultados que já estão no cache. Se no momento não houver resultados em cache, a consulta gerará novos resultados e os armazenará em cache pelo tempo de vida (TTL) especificado pela dica de consulta `enableResultCacheWithTTL`. Esse tempo de vida é especificado em segundos. Por exemplo, a seguinte consulta especifica um tempo de vida de sessenta segundos:
```
g.with('Neptune#enableResultCacheWithTTL', 60)
.V().has('genre','drama').in('likes')
```
Antes que os 60 segundos time-to-live terminem, você pode usar a mesma consulta (aqui`g.V().has('genre','drama').in('likes')`) com a dica de consulta `enableResultCache` ou com a dica de `enableResultCacheWithTTL` consulta para acessar os resultados em cache.
**nota**
O tempo de vida especificado com `enableResultCacheWithTTL` não afeta os resultados já armazenados em cache.
Se os resultados tiverem sido previamente armazenados em cache usando `enableResultCache`, o cache deverá primeiro ser explicitamente limpo antes que o `enableResultCacheWithTTL` gere novos resultados e os armazene em cache para o TTL especificado.
Se os resultados tiverem sido previamente armazenados em cache usando `enableResultCachewithTTL`, o TTL anterior deverá primeiro expirar antes que o `enableResultCacheWithTTL` gere novos resultados e os armazene em cache para o TTL especificado.
Após o término do tempo de vida, os resultados em cache da consulta são apagados e uma instância subsequente da mesma consulta gera novos resultados. Se `enableResultCacheWithTTL` estiver associado à consulta subsequente, os novos resultados serão armazenados em cache com o TTL especificado.
## Dica de consulta `invalidateResultCacheKey` do Gremlin
A dica de consulta `invalidateResultCacheKey` pode ter um valor `true` ou `false`. Um valor `true` faz com que os resultados em cache da consulta à qual `invalidateResultCacheKey` está associada sejam apagados. Por exemplo, o seguinte exemplo faz com que os resultados armazenados em cache para a chave de consulta `g.V().has('genre','drama').in('likes')` sejam apagados:
```
g.with('Neptune#invalidateResultCacheKey', true)
.V().has('genre','drama').in('likes')
```
O exemplo de consulta acima não faz com que seus novos resultados sejam armazenados em cache. Será possível incluir `enableResultCache` (ou `enableResultCacheWithTTL`) na mesma consulta se quiser armazenar em cache os novos resultados depois de limpar os existentes em cache:
```
g.with('Neptune#enableResultCache', true)
.with('Neptune#invalidateResultCacheKey', true)
.V().has('genre','drama').in('likes')
```
## Dica de consulta `invalidateResultCache` do Gremlin
A dica de consulta `invalidateResultCache` pode ter um valor `true` ou `false`. Um valor `true` faz com que todos os resultados no cache de resultados sejam apagados. Por exemplo:
```
g.with('Neptune#invalidateResultCache', true)
.V().has('genre','drama').in('likes')
```
O exemplo de consulta acima não faz com que seus resultados sejam armazenados em cache. Será possível incluir `enableResultCache` (ou `enableResultCacheWithTTL`) na mesma consulta se quiser armazenar em cache os novos resultados depois de limpar completamente o cache existente:
```
g.with('Neptune#enableResultCache', true)
.with('Neptune#invalidateResultCache', true)
.V().has('genre','drama').in('likes')
```
## Dica de consulta `numResultsCached` do Gremlin
A dica de consulta `numResultsCached` só pode ser usada com consultas que contenham `iterate()` e especifica o número máximo de resultados a serem armazenados em cache para a consulta à qual está associada. Observe que os resultados armazenados em cache quando `numResultsCached` está presente não são exibidos, apenas os armazenados em cache.
Por exemplo, a seguinte consulta especifica que até 100 dos resultados devem ser armazenados em cache, mas nenhum desses resultados deve ser gerado:
```
g.with('Neptune#enableResultCache', true)
.with('Neptune#numResultsCached', 100)
.V().has('genre','drama').in('likes').iterate()
```
Depois, você pode usar uma consulta como a seguinte para recuperar uma variedade de resultados em cache (aqui, os dez primeiros):
```
g.with('Neptune#enableResultCache', true)
.with('Neptune#numResultsCached', 100)
.V().has('genre','drama').in('likes').range(0, 10)
```
## Dica de consulta `noCacheExceptions` do Gremlin
A dica de consulta `noCacheExceptions` pode ter um valor `true` ou `false`. Um valor `true` faz com que todas as exceções relacionadas ao cache de resultados sejam suprimidas. Por exemplo:
```
g.with('Neptune#enableResultCache', true)
.with('Neptune#noCacheExceptions', true)
.V().has('genre','drama').in('likes')
```
Especificamente, isso suprime a `QueryLimitExceededException`, que será gerada se os resultados de uma consulta forem grandes demais para caber no cache de resultados.