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á.
# Operadores SPARQL `explain` no Neptune
As seções a seguir descrevem os operadores e os parâmetros para o atributo `explain` do SPARQL que está disponível no Amazon Neptune.
**Importante**
O recurso `explain` do SPARQL ainda está sendo refinado. Os operadores e os parâmetros documentados aqui podem ser alterados em versões futuras.
**Topics**
+ [Operador `Aggregation`](#sparql-explain-operator-aggregation)
+ [Operador `ConditionalRouting`](#sparql-explain-operator-conditional-routing)
+ [Operador `Copy`](#sparql-explain-operator-copy)
+ [Operador `DFENode`](#sparql-explain-operator-dfenode)
+ [Operador `Distinct`](#sparql-explain-operator-distinct)
+ [Operador `Federation`](#sparql-explain-operator-federation)
+ [Operador `Filter`](#sparql-explain-operator-filter)
+ [Operador `HashIndexBuild`](#sparql-explain-operator-hash-index-build)
+ [Operador `HashIndexJoin`](#sparql-explain-operator-hash-index-join)
+ [Operador `MergeJoin`](#sparql-explain-operator-merge-join)
+ [Operador `NamedSubquery`](#sparql-explain-operator-named-subquery)
+ [Operador `PipelineJoin`](#sparql-explain-operator-pipeline-join)
+ [Operador `PipelineCountJoin`](#sparql-explain-operator-pipeline-count-join)
+ [Operador `PipelinedHashIndexJoin`](#sparql-explain-operator-pipeline-hash-index-join)
+ [Operador `Projection`](#sparql-explain-operator-projection)
+ [Operador `PropertyPath`](#sparql-explain-operator-property-path)
+ [Operador `TermResolution`](#sparql-explain-operator-term-resolution)
+ [Operador `Slice`](#sparql-explain-operator-slice)
+ [Operador `SolutionInjection`](#sparql-explain-operator-solution-injection)
+ [Operador `Sort`](#sparql-explain-operator-sort)
+ [Operador `VariableAlignment`](#sparql-explain-operator-variable-alignment)
## Operador `Aggregation`
Executa uma ou mais agregações, implementando a semântica dos operadores de agregação do SPARQL, como `count`, `max`, `min`, `sum` e assim por diante.
`Aggregation` é fornecido com agrupamento opcional usando cláusulas `groupBy` e restrições `having` opcionais.
**Argumentos**
+ `groupBy`: (*opcional*) fornece uma cláusula `groupBy` que especifica a sequência de expressões de acordo com a qual as soluções de entrada são agrupadas.
+ `aggregates`: (*obrigatório*) especifica uma lista ordenada de expressões de agregação.
+ `having`: (*opcional*) adiciona restrições para filtragem em grupos, como implícito pela cláusula `having` na consulta do SPARQL.
## Operador `ConditionalRouting`
Roteia soluções de entrada com base em uma determinada condição. As soluções que atendem à condição são roteadas para o ID do operador referenciado por `Out #1`, enquanto as soluções que não atendem são roteadas para o operador referenciado por `Out #2`.
**Argumentos**
+ `condition`: (*obrigatório*) a condição de roteamento.
## Operador `Copy`
Delega o fluxo da solução conforme especificado pelo modo especificado.
**Modos**
+ `forward`: encaminha as soluções para o operador posterior identificado por `Out #1`.
+ `duplicate`: duplica as soluções e as encaminha para cada um dos dois operadores identificados por `Out #1` e `Out #2`.
O `Copy` não tem argumentos.
## Operador `DFENode`
Esse operador é uma abstração do plano executado pelo mecanismo de consulta alternativa do DFE. O plano detalhado do DFE é descrito nos argumentos para esse operador. No momento, o argumento está sobrecarregado para conter as estatísticas detalhadas de runtime do plano do DFE. Ele contém o tempo gasto nas várias etapas da execução da consulta pelo DFE.
A árvore de sintaxe abstrata (AST) de lógica otimizada para o plano de consulta do DFE é impressa com informações sobre os tipos de operadores que foram considerados durante o planejamento e os melhores e piores custos associados à execução dos operadores. O AST consiste nos seguintes tipos de nós no momento:
+ `DFEJoinGroupNode`: representa uma junção de um ou mais `DFEPatternNodes`.
+ `DFEPatternNode`: encapsula um padrão subjacente usando as tuplas correspondentes que se projetam para fora do banco de dados subjacente.
A subseção, `Statistics & Operator histogram`, contém detalhes sobre o tempo de execução do plano `DataflowOp` e o detalhamento do tempo de CPU usado por cada operador. Abaixo disso, há uma tabela que imprime estatísticas detalhadas de runtime do plano executado pelo DFE.
**nota**
Como o suporte do DFE para SPARQL é um recurso experimental, o formato exato de sua `explain` saída pode mudar.
## Operador `Distinct`
Calcula a projeção distinta em um subconjunto das variáveis, eliminando duplicatas. Como resultado, o número de soluções do fluxo de entrada é maior ou igual ao número de soluções do fluxo de saída.
**Argumentos**
+ `vars`: (*obrigatório*) as variáveis às quais aplicar a projeção `Distinct`.
## Operador `Federation`
Transmite uma consulta especificada para um endpoint SPARQL remoto especificado.
**Argumentos**
+ `endpoint`: (*obrigatório*) o URL do endpoint na declaração `SERVICE` do SPARQL. Pode ser uma string constante ou, se o endpoint da consulta for determinado com base em uma variável dentro da mesma consulta, pode ser o nome da variável.
+ `query`: (*obrigatório*) a string de consulta reconstruída a ser enviada ao endpoint remoto. O mecanismo adiciona prefixos padrão a essa consulta, mesmo quando o cliente não especifica nenhum.
+ `silent`: (*obrigatório*) um booliano que indica se a palavra-chave `SILENT` apareceu após a palavra-chave. `SILENT` ordena ao mecanismo para não causar falha na consulta inteira, mesmo que a parte remota de `SERVICE` falhe.
## Operador `Filter`
Filtra as soluções de entrada. Somente as soluções que atendem à condição do filtro são encaminhadas para o operador upstream, e todas as outras são descartadas.
**Argumentos**
+ `condition`: (*obrigatório*) a condição de filtro.
## Operador `HashIndexBuild`
Usa uma lista de associações e as transfere para um índice de hash cujo nome é definido pelo argumento `solutionSet`. Normalmente, os operadores subsequentes executam junções nesse conjunto de soluções, referindo-se a ele por esse nome.
**Argumentos**
+ `solutionSet`: (*obrigatório*) o nome do conjunto de soluções do índice de hash.
+ `sourceType`: (*obrigatório*) o tipo da origem a partir da qual as associações a serem armazenadas no índice de hash são obtidas:
+ `pipeline`: transfere as soluções de entrada do operador posterior para o pipeline de operadores no índice de hash.
+ `binding set`: transfere o conjunto de associações fixas especificado pelo argumento `sourceBindingSet` ao índice de hash.
+ `sourceBindingSet`: (*opcional*) se o valor do argumento `sourceType` for `binding set`, esse argumento especificará o conjunto de associações estáticas a serem transferidas ao índice de hash.
## Operador `HashIndexJoin`
Une as soluções de entrada no conjunto de soluções do índice de hash identificado pelo argumento `solutionSet`.
**Argumentos**
+ `solutionSet`: (*obrigatório*) o nome do conjunto de soluções no qual fazer a junção. Esse deve ser um índice de hash que foi criado em uma etapa anterior usando o operador `HashIndexBuild`.
+ `joinType`: (*obrigatório*) o tipo de junção a ser executada:
+ `join`: uma junção normal, que exige uma correspondência exata entre todas as variáveis compartilhadas.
+ `optional`: uma junção `optional` que usa a semântica do operador `OPTIONAL` do SPARQL.
+ `minus`: uma operação `minus` mantém um mapeamento para o qual não existe nenhum parceiro de junção usando o operador `MINUS` do SPARQL.
+ `existence check`: confere se há um parceiro de junção e associa a variável `existenceCheckResultVar` ao resultado dessa verificação.
+ `constraints`: (*opcional*) restrições adicionais de junção que são consideradas durante a junção. Junções que não atendem a essas restrições são descartadas.
+ `existenceCheckResultVar`: (*opcional*) Usado apenas para junções em que `joinType` é igual a `existence check` (veja o argumento `joinType` anterior).
## Operador `MergeJoin`
Uma junção de mesclagem em vários conjuntos de soluções, conforme identificado pelo argumento `solutionSets`.
**Argumentos**
+ `solutionSets`: (*obrigatório*) os conjuntos de soluções a serem unidos.
## Operador `NamedSubquery`
Aciona a avaliação da subconsulta identificada pelo argumento `subQuery` e transfere o resultado para o conjunto de soluções especificado pelo argumento `solutionSet`. As soluções de entrada para o operador são encaminhadas para a subconsulta e então para o próximo operador.
**Argumentos**
+ `subQuery`: (*obrigatório*) o nome da subconsulta a ser avaliada. A subconsulta é renderizada explicitamente na saída.
+ `solutionSet`: (*obrigatório*) o nome do conjunto de soluções no qual armazenar o resultado da subconsulta.
## Operador `PipelineJoin`
Recebe como entrada a saída do operador anterior e junta-a no padrão de tupla definido pelo argumento `pattern`.
**Argumentos**
+ `pattern`— (*Obrigatório*) O padrão, que assume a forma de uma tupla e subject-predicate-object, opcionalmente, de gráfico que está por trás da junção. Se `distinct` for especificado para o padrão, a junção extrairá apenas as soluções distintas das variáveis de projeção especificadas pelo argumento `projectionVars`, em vez de todas as soluções correspondentes.
+ `inlineFilters`: (*opcional*) um conjunto de filtros a serem aplicados às variáveis no padrão. O padrão é avaliado em conjunto com esses filtros.
+ `joinType`: (*obrigatório*) o tipo de junção a ser executada:
+ `join`: uma junção normal, que exige uma correspondência exata entre todas as variáveis compartilhadas.
+ `optional`: uma junção `optional` que usa a semântica do operador `OPTIONAL` do SPARQL.
+ `minus`: uma operação `minus` mantém um mapeamento para o qual não existe nenhum parceiro de junção usando o operador `MINUS` do SPARQL.
+ `existence check`: confere se há um parceiro de junção e associa a variável `existenceCheckResultVar` ao resultado dessa verificação.
+ `constraints`: (*opcional*) restrições adicionais de junção que são consideradas durante a junção. Junções que não atendem a essas restrições são descartadas.
+ `projectionVars`: (*opcional*) as variáveis da projeção. Usado em combinação com `distinct := true` para impor a extração de projeções distintas em um conjunto de variáveis especificado.
+ `cutoffLimit`: (*opcional*) um limite de corte para o número de parceiros de junção extraídos. Embora não exista nenhum limite por padrão, você pode definir isso como 1 ao executar junções para implementar cláusulas `FILTER (NOT) EXISTS`, em que é suficiente provar ou refutar que existe um parceiro de junção.
## Operador `PipelineCountJoin`
Variante do `PipelineJoin`. Em vez de juntar, ele simplesmente conta os parceiros da junção correspondente e associa a contagem à variável especificada pelo argumento `countVar`.
**Argumentos**
+ `countVar`: (*obrigatório*) a variável à qual o resultado da contagem, ou seja, o número de parceiros da junção, deve ser associado.
+ `pattern`— (*Obrigatório*) O padrão, que assume a forma de uma tupla e subject-predicate-object, opcionalmente, de gráfico que está por trás da junção. Se `distinct` for especificado para o padrão, a junção extrairá apenas as soluções distintas das variáveis de projeção especificadas pelo argumento `projectionVars`, em vez de todas as soluções correspondentes.
+ `inlineFilters`: (*opcional*) um conjunto de filtros a serem aplicados às variáveis no padrão. O padrão é avaliado em conjunto com esses filtros.
+ `joinType`: (*obrigatório*) o tipo de junção a ser executada:
+ `join`: uma junção normal, que exige uma correspondência exata entre todas as variáveis compartilhadas.
+ `optional`: uma junção `optional` que usa a semântica do operador `OPTIONAL` do SPARQL.
+ `minus`: uma operação `minus` mantém um mapeamento para o qual não existe nenhum parceiro de junção usando o operador `MINUS` do SPARQL.
+ `existence check`: confere se há um parceiro de junção e associa a variável `existenceCheckResultVar` ao resultado dessa verificação.
+ `constraints`: (*opcional*) restrições adicionais de junção que são consideradas durante a junção. Junções que não atendem a essas restrições são descartadas.
+ `projectionVars`: (*opcional*) as variáveis da projeção. Usado em combinação com `distinct := true` para impor a extração de projeções distintas em um conjunto de variáveis especificado.
+ `cutoffLimit`: (*opcional*) um limite de corte para o número de parceiros de junção extraídos. Embora não exista nenhum limite por padrão, você pode definir isso como 1 ao executar junções para implementar cláusulas `FILTER (NOT) EXISTS`, em que é suficiente provar ou refutar que existe um parceiro de junção.
## Operador `PipelinedHashIndexJoin`
Este é um índice de hash de all-in-one construção e um operador de junção. Ele pega uma lista de associações, as agrupa em um índice de hash e, depois, une as soluções de entrada com o índice de hash.
**Argumentos**
+ `sourceType`: (*obrigatório*) o tipo da origem a partir da qual as associações a serem armazenadas no índice de hash são obtidas. Um de:
+ `pipeline`: faz com que o `PipelinedHashIndexJoin` transfira as soluções de entrada do operador posterior no pipeline de operadores para o índice de hash.
+ `binding set`: faz com que `PipelinedHashIndexJoin` transfira o conjunto de associações fixas especificado pelo argumento `sourceBindingSet` para o índice de hash.
+ `sourceSubQuery `: (*opcional*) se o valor do argumento `sourceType` for `pipeline`, esse argumento especificará a subconsulta avaliada e agrupada no índice de hash.
+ `sourceBindingSet `: (*opcional*) se o valor do argumento `sourceType` for `binding set`, esse argumento especificará o conjunto de associações estáticas a serem transferidas para o índice de hash.
+ `joinType`: (*obrigatório*) o tipo de junção a ser executada:
+ `join`: uma junção normal, que exige uma correspondência exata entre todas as variáveis compartilhadas.
+ `optional`: uma junção `optional` que usa a semântica do operador `OPTIONAL` do SPARQL.
+ `minus`: uma operação `minus` mantém um mapeamento para o qual não existe nenhum parceiro de junção usando o operador `MINUS` do SPARQL.
+ `existence check`: confere se há um parceiro de junção e associa a variável `existenceCheckResultVar` ao resultado dessa verificação.
+ `existenceCheckResultVar`: (*opcional*) usado apenas para junções em que `joinType` é igual a `existence check` (veja o argumento joinType acima).
## Operador `Projection`
Projeta sobre um subconjunto de variáveis. O número de soluções do fluxo de entrada é igual ao número de soluções do fluxo de saída, mas a forma da solução é diferente, dependendo da configuração do modo.
**Modos**
+ `retain`: reter nas soluções apenas as variáveis que são especificadas pelo argumento `vars`.
+ `drop`: descartar todas as variáveis especificadas pelo argumento `vars`.
**Argumentos**
+ `vars`: (*obrigatório*) as variáveis a serem retidas ou descartadas, dependendo da configuração do modo.
## Operador `PropertyPath`
Habilita caminhos de propriedades recursivos, como `+` ou `*`. O Neptune implementa uma abordagem de iteração de ponto fixo com base em um modelo especificado pelo argumento `iterationTemplate`. As variáveis conhecidas do lado esquerdo ou direito são associadas no modelo para cada iteração de ponto fixo, até que nenhuma nova solução possa ser encontrada.
**Argumentos**
+ `iterationTemplate`: (*obrigatório*) o nome do modelo de subconsulta usado para implementar a iteração de ponto fixo.
+ `leftTerm`: (*obrigatório*) o termo (variável ou constante) no lado esquerdo do caminho da propriedade.
+ `rightTerm`: (*obrigatório*) o termo (variável ou constante) no lado direito do caminho da propriedade.
+ `lowerBound`: (*obrigatório*) O limite inferior para iteração de ponto fixo (`0` para consultas `*` ou `1` para consultas `+`).
## Operador `TermResolution`
Converte valores de identificadores de strings internas de volta para suas strings externas correspondentes, ou converte strings externas em valores de identificadores de strings internas, dependendo do modo.
**Modos**
+ `value2id`— Mapeia termos como literais e URIs para valores de ID internos correspondentes (codificação para valores internos).
+ `id2value`— Mapeia valores de ID internos para os termos correspondentes, como literais e URIs (decodificação de valores internos).
**Argumentos**
+ `vars`— (*Obrigatório*) Especifica as variáveis cujas cadeias de caracteres ou seqüências de caracteres internas IDs devem ser mapeadas.
## Operador `Slice`
Implementa um slice sobre o fluxo da solução de entrada, usando a semântica das cláusulas `LIMIT` e `OFFSET` do SPARQL.
**Argumentos**
+ `limit`: (*opcional*) um limite das soluções a serem encaminhadas.
+ `offset`: (*opcional*) o deslocamento em que as soluções são avaliadas para encaminhamento.
## Operador `SolutionInjection`
Não recebe nenhuma entrada. Injeta estaticamente soluções no plano de consulta e registra-as no argumento `solutions`.
Os planos de consulta sempre começam com essa injeção estática. Se as soluções estáticas a serem injetadas puderem ser derivadas da própria consulta combinando várias origens de associações estáticas (por exemplo, de cláusulas `VALUES` ou `BIND`), o operador `SolutionInjection` injetará essas soluções estáticas derivadas. No caso mais simples, essas refletem associações que são implícitas por uma cláusula `VALUES` externa.
Se nenhuma solução estática puder ser derivada da consulta, `SolutionInjection` injetará a solução vazia, chamada de solução universal, que é expandida e multiplicada durante todo o processo de avaliação da consulta.
**Argumentos**
+ `solutions`: (*obrigatório*) a sequência de soluções injetadas pelo operador.
## Operador `Sort`
Classifica o conjunto de soluções usando as condições de classificação especificadas.
**Argumentos**
+ `sortOrder`: (*obrigatório*) lista ordenada de variáveis, cada uma contendo um identificador `ASC` (crescente) ou `DESC` (decrescente), usado sequencialmente para classificar o conjunto de soluções.
## Operador `VariableAlignment`
Inspeciona uma por uma das soluções, executando alinhamento em cada uma por meio de duas variáveis: uma `sourceVar` especificada e uma `targetVar` especificada.
Se `sourceVar` e `targetVar` em uma solução tiverem o mesmo valor, as variáveis serão consideradas alinhadas, e a solução será encaminhada, com a `sourceVar` redundante descartada.
Se as variáveis estiverem associadas a valores diferentes, a solução será filtrada por completo.
**Argumentos**
+ `sourceVar`: (*obrigatório*) a variável de origem, a ser comparada com a variável de destino. Se o alinhamento for bem-sucedido em uma solução, indicando que as duas variáveis têm o mesmo valor, a variável de origem será descartada.
+ `targetVar`: (*obrigatório*) a variável de destino, com a qual a variável de origem é comparada. É retida mesmo quando o alinhamento é bem-sucedido.