Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Opérateurs Neptune SPARQL `explain` Les sections suivantes décrivent les opérateurs et les paramètres de la fonctionnalité SPARQL `explain` actuellement disponibles dans Amazon Neptune. **Important** La fonction `explain` SPARQL est encore en cours d'affinement. Les opérateurs et paramètres documentés ici sont susceptibles de changer dans de futures versions. **Topics** + [Opérateur `Aggregation`](#sparql-explain-operator-aggregation) + [Opérateur `ConditionalRouting`](#sparql-explain-operator-conditional-routing) + [Opérateur `Copy`](#sparql-explain-operator-copy) + [Opérateur `DFENode`](#sparql-explain-operator-dfenode) + [Opérateur `Distinct`](#sparql-explain-operator-distinct) + [Opérateur `Federation`](#sparql-explain-operator-federation) + [Opérateur `Filter`](#sparql-explain-operator-filter) + [Opérateur `HashIndexBuild`](#sparql-explain-operator-hash-index-build) + [Opérateur `HashIndexJoin`](#sparql-explain-operator-hash-index-join) + [Opérateur `MergeJoin`](#sparql-explain-operator-merge-join) + [Opérateur `NamedSubquery`](#sparql-explain-operator-named-subquery) + [Opérateur `PipelineJoin`](#sparql-explain-operator-pipeline-join) + [Opérateur `PipelineCountJoin`](#sparql-explain-operator-pipeline-count-join) + [Opérateur `PipelinedHashIndexJoin`](#sparql-explain-operator-pipeline-hash-index-join) + [Opérateur `Projection`](#sparql-explain-operator-projection) + [Opérateur `PropertyPath`](#sparql-explain-operator-property-path) + [Opérateur `TermResolution`](#sparql-explain-operator-term-resolution) + [Opérateur `Slice`](#sparql-explain-operator-slice) + [Opérateur `SolutionInjection`](#sparql-explain-operator-solution-injection) + [Opérateur `Sort`](#sparql-explain-operator-sort) + [Opérateur `VariableAlignment`](#sparql-explain-operator-variable-alignment) ## Opérateur `Aggregation` Effectue une ou plusieurs agrégations, en implémentant la sémantique des opérateurs d'agrégation SPARQL tels que `count`, `max`, `min`, `sum`, etc. `Aggregation` est fourni avec un regroupement facultatif à l'aide de clauses `groupBy` et de contraintes `having` facultatives. **Arguments** + `groupBy` : (*facultatif*) fournit une clause `groupBy` qui spécifie la séquence d'expressions selon laquelle les solutions entrantes sont regroupées. + `aggregates` : (*obligatoire*) spécifie une liste ordonnée d'expressions d'agrégation. + `having` : (*facultatif*) ajoute des contraintes pour filtrer des groupes comme impliqué par la clause `having` dans la requête SPARQL. ## Opérateur `ConditionalRouting` Achemine des solutions entrants en fonction d'une condition. Les solutions qui remplissent les conditions sont acheminées vers l'ID d'opérateur référencé par `Out #1`, tandis que les solutions qui ne les remplissent pas sont acheminées vers l'opérateur référencé par `Out #2`. **Arguments** + `condition` : (*obligatoire*) condition de routage. ## Opérateur `Copy` Délègue le flux de solution comme spécifié par le mode indiqué. **Modes** + `forward` : transmet les solutions à l'opérateur en aval identifié par `Out #1`. + `duplicate` : duplique les solutions et les transmet à chacun des deux opérateurs identifiées par `Out #1` et `Out #2`. `Copy` ne comporte aucun argument. ## Opérateur `DFENode` Cet opérateur est une abstraction du plan exécuté par le moteur de requête alternatif DFE. Le plan DFE détaillé est décrit dans les arguments de cet opérateur. L'argument est actuellement surchargé pour contenir les statistiques d'exécution détaillées du plan DFE. Il contient le temps consacré aux différentes étapes de l'exécution des requêtes par le DFE. L'arbre syntaxique abstrait optimisé (AST) logique pour le plan de requêtes DFE est imprimé avec des informations sur les types d'opérateurs pris en compte lors de la planification et les coûts les plus et les moins favorables associés à l'exécution des opérateurs. L'arbre AST comprend actuellement les types de nœuds suivants : + `DFEJoinGroupNode` : représente une jointure d'un ou de plusieurs éléments `DFEPatternNodes`. + `DFEPatternNode` : encapsule un modèle sous-jacent à l'aide duquel les tuples correspondants sont projetés hors de la base de données sous-jacente. La sous-section, `Statistics & Operator histogram`, contient des détails sur le temps d'exécution du plan `DataflowOp` et sur la répartition du temps CPU utilisé par chaque opérateur. En dessous se trouve un tableau qui affiche les statistiques d'exécution détaillées du plan exécuté par le DFE. **Note** Le support DFE pour SPARQL étant une fonctionnalité expérimentale, le format exact de sa `explain` sortie peut changer. ## Opérateur `Distinct` Calcule la projection distincte sur un sous-ensemble des variables, en éliminant les doublons. Par conséquent, le nombre de solutions en entrée est supérieur ou égal au nombre de solutions en sortie. **Arguments** + `vars` : (*obligatoire*) variables auxquelles appliquer la projection `Distinct`. ## Opérateur `Federation` Transmet une requête spécifique à un point de terminaison SPARQL distant spécifique. **Arguments** + `SERVICE` : (*obligatoire*) URL du point de terminaison dans la déclaration SPARQL `endpoint`. Il peut s'agir d'une chaîne constante, ou, si le point de terminaison de la requête est déterminé en fonction d'une variable au sein de la même requête, il peut s'agir du nom de la variable. + `query` : (*obligatoire*) chaîne de requête reconstruite à envoyer au point de terminaison distant. Le moteur ajoute des préfixes par défaut à cette requête, même lorsque le client n'en spécifie aucun. + `silent` : (*obligatoire*) valeur booléenne qui indique si le mot-clé `SILENT` apparaît après le mot-clé. `SILENT` indique au moteur de ne pas faire échouer l'ensemble de la requête, même si la partie `SERVICE` distante échoue. ## Opérateur `Filter` Filtre les solutions entrantes. Seules les solutions qui remplissent la condition de filtre sont transmises à l'opérateur en amont. Toutes les autres sont supprimées. **Arguments** + `condition` : (*obligatoire*) condition de filtre. ## Opérateur `HashIndexBuild` Prend une liste de liaisons et les place dans un index de hachage dont le nom est défini par l'argument `solutionSet`. En général, les opérateurs suivants effectuent des jointures en fonction de cette solution, en y faisant référence par ce nom. **Arguments** + `solutionSet` : (*obligatoire*) nom de l'ensemble de solutions de l'index de hachage. + `sourceType` : (*obligatoire*) type de la source à partir de laquelle les liaisons à stocker dans l'index de hachage sont obtenues : + `pipeline` : place les solutions entrantes de l'opérateur en aval dans le pipeline des opérateurs dans l'index de hachage. + `binding set` : place l'ensemble de liaisons fixes spécifié par l'argument `sourceBindingSet` dans l'index de hachage. + `sourceBindingSet` : (*facultatif*) si la valeur de l'argument `sourceType` est `binding set`, cet argument spécifie l'ensemble de liaisons statiques à placer dans l'index de hachage. ## Opérateur `HashIndexJoin` Joint les solutions entrantes par rapport à l'ensemble de solutions de l'index de hachage, identifié par l'argument `solutionSet`. **Arguments** + `solutionSet` : (*obligatoire*) nom de l'ensemble de solutions sur lequel effectuer la jointure. Il doit s'agir d'un index de hachage qui a été créé dans une étape précédente à l'aide de l'opérateur `HashIndexBuild`. + `joinType` : (*obligatoire*) type de jointure à effectuer : + `join` : jointure normale, nécessitant une correspondance exacte entre toutes les variables partagées. + `optional` : jointure `OPTIONAL` qui utilise la sémantique de l'opérateur `optional` SPARQL. + `minus` : une opération `MINUS` conserve un mappage pour lequel aucun partenaire de jointure n'existe, à l'aide de la sémantique de l'opérateur `minus` SPARQL. + `existence check` : vérifie s'il existe ou non un partenaire de jointure et lie la variable `existenceCheckResultVar` au résultat de cette vérification. + `constraints` : (*facultatif*) des contraintes de jointure supplémentaires sont prises en compte lors de la jointure. Les jointures qui ne remplissent pas ces contraintes sont rejetées. + `existenceCheckResultVar` : (*facultatif*) utilisé uniquement pour les jointures où `joinType` est égal à `existence check` (voir l'argument `joinType` ci-dessus). ## Opérateur `MergeJoin` Jointure par fusion sur plusieurs ensembles de solutions, identifiés par l'argument `solutionSets`. **Arguments** + `solutionSets` : (*obligatoire*) ensembles de solutions à joindre. ## Opérateur `NamedSubquery` Déclenche l'évaluation de la sous-requête identifiée par l'argument `subQuery` et place le résultat dans l'ensemble de solutions spécifié par l'argument `solutionSet`. Les solutions entrantes pour l'opérateur sont transmises à la sous-requête, puis à l'opérateur suivant. **Arguments** + `subQuery` : (*obligatoire*) nom de la sous-requête à évaluer. La sous-requête est affichée explicitement dans la sortie. + `solutionSet` : (*obligatoire*) nom de l'ensemble de solutions dans lequel vous souhaitez stocker le résultat de la sous-requête. ## Opérateur `PipelineJoin` Reçoit en tant qu'entrée la sortie de l'opérateur précédent et la joint en fonction du modèle de tuple défini par l'argument `pattern`. **Arguments** + `pattern`— (*Obligatoire*) Le modèle, qui prend la forme d'un tuple subject-predicate-object, et éventuellement d'un tuple -graph, qui sous-tend la jointure. Si `distinct` est spécifié pour le modèle, la jointure extrait uniquement les solutions distinctes des variables de projection spécifiées par l'argument `projectionVars`, et non toutes les solutions qui correspondent. + `inlineFilters` : (*facultatif*) ensemble de filtres à appliquer aux variables dans le modèle. Le modèle est évalué conjointement avec ces filtres. + `joinType` : (*obligatoire*) type de jointure à effectuer : + `join` : jointure normale, nécessitant une correspondance exacte entre toutes les variables partagées. + `optional` : jointure `OPTIONAL` qui utilise la sémantique de l'opérateur `optional` SPARQL. + `minus` : une opération `MINUS` conserve un mappage pour lequel aucun partenaire de jointure n'existe, à l'aide de la sémantique de l'opérateur `minus` SPARQL. + `existence check` : vérifie s'il existe ou non un partenaire de jointure et lie la variable `existenceCheckResultVar` au résultat de cette vérification. + `constraints` : (*facultatif*) des contraintes de jointure supplémentaires sont prises en compte lors de la jointure. Les jointures qui ne remplissent pas ces contraintes sont rejetées. + `projectionVars` : (*facultatif*) variables de la projection. Utilisé en combiné avec `distinct := true` pour appliquer l'extraction de projections distinctes sur un ensemble de variables spécifié. + `cutoffLimit` : (*facultatif*) limite de coupure pour le nombre de partenaires de jointure extraits. Même s'il n'existe pas de limite par défaut, vous pouvez définir cet argument sur 1 lorsque vous effectuez des jointures pour implémenter des clauses `FILTER (NOT) EXISTS`, où il suffit de prouver ou de réfuter qu'il existe une jointure partenaire. ## Opérateur `PipelineCountJoin` Variante de `PipelineJoin`. Au lieu d'effectuer une jointure, compte uniquement les partenaires de jointure correspondants et lie le comptage à la variable spécifiée par l'argument `countVar`. **Arguments** + `countVar` : (*obligatoire*) variable à laquelle le résultat du décompte, à savoir le nombre de partenaires de jointure, doit être limitée. + `pattern`— (*Obligatoire*) Le modèle, qui prend la forme d'un tuple subject-predicate-object, et éventuellement d'un tuple -graph, qui sous-tend la jointure. Si `distinct` est spécifié pour le modèle, la jointure extrait uniquement les solutions distinctes des variables de projection spécifiées par l'argument `projectionVars`, et non toutes les solutions qui correspondent. + `inlineFilters` : (*facultatif*) ensemble de filtres à appliquer aux variables dans le modèle. Le modèle est évalué conjointement avec ces filtres. + `joinType` : (*obligatoire*) type de jointure à effectuer : + `join` : jointure normale, nécessitant une correspondance exacte entre toutes les variables partagées. + `optional` : jointure `OPTIONAL` qui utilise la sémantique de l'opérateur `optional` SPARQL. + `minus` : une opération `MINUS` conserve un mappage pour lequel aucun partenaire de jointure n'existe, à l'aide de la sémantique de l'opérateur `minus` SPARQL. + `existence check` : vérifie s'il existe ou non un partenaire de jointure et lie la variable `existenceCheckResultVar` au résultat de cette vérification. + `constraints` : (*facultatif*) des contraintes de jointure supplémentaires sont prises en compte lors de la jointure. Les jointures qui ne remplissent pas ces contraintes sont rejetées. + `projectionVars` : (*facultatif*) variables de la projection. Utilisé en combiné avec `distinct := true` pour appliquer l'extraction de projections distinctes sur un ensemble de variables spécifié. + `cutoffLimit` : (*facultatif*) limite de coupure pour le nombre de partenaires de jointure extraits. Même s'il n'existe pas de limite par défaut, vous pouvez définir cet argument sur 1 lorsque vous effectuez des jointures pour implémenter des clauses `FILTER (NOT) EXISTS`, où il suffit de prouver ou de réfuter qu'il existe une jointure partenaire. ## Opérateur `PipelinedHashIndexJoin` Il s'agit d'un index de hachage de all-in-one construction et d'un opérateur de jointure. Il utilise une liste de liaisons, les regroupe dans un index de hachage, puis joint les solutions entrantes à l'index de hachage. **Arguments** + `sourceType` : (*obligatoire*) type de la source à partir de laquelle les liaisons à stocker dans l'index de hachage sont obtenues : + `pipeline` : incite `PipelinedHashIndexJoin` à placer les solutions entrantes de l'opérateur en aval dans le pipeline des opérateurs dans l'index de hachage. + `binding set` : incite `PipelinedHashIndexJoin` à place l'ensemble de liaisons fixes spécifié par l'argument `sourceBindingSet` dans l'index de hachage. + `sourceSubQuery ` : (*facultatif*) si la valeur de l'argument `sourceType` est `pipeline`, cet argument indique la sous-requête qui est évaluée et insérée dans l'index de hachage. + `sourceBindingSet ` : (*facultatif*) si la valeur de l'argument `sourceType` est `binding set`, cet argument spécifie l'ensemble de liaisons statiques à placer dans l'index de hachage. + `joinType` : (*obligatoire*) type de jointure à effectuer : + `join` : jointure normale, nécessitant une correspondance exacte entre toutes les variables partagées. + `optional` : jointure `OPTIONAL` qui utilise la sémantique de l'opérateur `optional` SPARQL. + `minus` : une opération `MINUS` conserve un mappage pour lequel aucun partenaire de jointure n'existe, à l'aide de la sémantique de l'opérateur `minus` SPARQL. + `existence check` : vérifie s'il existe ou non un partenaire de jointure et lie la variable `existenceCheckResultVar` au résultat de cette vérification. + `existenceCheckResultVar` : (*facultatif*) utilisé uniquement pour les jointures où `joinType` est égal à `existence check` (voir l'argument joinType ci-dessus). ## Opérateur `Projection` Effectue une projection sur un sous-ensemble des variables. Le nombre de solutions en entrée est égal au nombre de solutions en sortie, mais la forme de la solution diffère selon le paramètre de mode. **Modes** + `retain` : ne conserve dans les solutions que les variables qui sont spécifiées par l'argument `vars`. + `drop` : abandonne toutes les variables qui sont spécifiées par l'argument `vars`. **Arguments** + `vars` : (*obligatoire*) variables à conserver ou à abandonner, en fonction du paramètre de mode. ## Opérateur `PropertyPath` Active les chemins de propriétés récursifs tels que `+` ou `*`. Neptune met en œuvre une approche d'itération à point fixe basée sur un modèle spécifié par l'argument `iterationTemplate`. Les variables de gauche ou de droite connues sont liées dans le modèle pour chaque itération de type point fixe, jusqu'à ce qu'aucune autre nouvelle solution ne puisse être trouvée. **Arguments** + `iterationTemplate` : (*obligatoire*) nom du modèle de sous-requête utilisé pour implémenter l'itération de type point fixe. + `leftTerm` : (*obligatoire*) terme (variable ou constante) à gauche du chemin de propriété. + `rightTerm` : (*obligatoire*) terme (variable ou constante) à droite du chemin de propriété. + `lowerBound` : (*obligatoire*) limite inférieure pour une itération de type point fixe (`0` pour les requêtes `*` ou `1` pour les requêtes `+`). ## Opérateur `TermResolution` Reconvertit des valeurs d'identifiant de chaîne interne en leurs chaînes externes correspondantes, ou convertit des chaînes externes en valeurs d'identifiant de chaîne interne, en fonction du mode. **Modes** + `value2id`— Associe des termes tels que les littéraux URIs aux valeurs d'identification internes correspondantes (encodage en valeurs internes). + `id2value`— Associe les valeurs d'identification internes aux termes correspondants tels que les littéraux et URIs (décodage des valeurs internes). **Arguments** + `vars`— (*Obligatoire*) Spécifie les variables dont les chaînes ou chaînes internes IDs doivent être mappées. ## Opérateur `Slice` Implémente une tranche sur le flux de solution entrant, à l'aide de la sémantique des clauses `LIMIT` et `OFFSET` SPARQL. **Arguments** + `limit` : (*facultatif*) limite applicable aux solutions à transmettre. + `offset` : (*facultatif*) décalage par rapport auquel les solutions sont évaluées pour la transmission. ## Opérateur `SolutionInjection` Ne reçoit aucune entrée. Injecte statiquement des solutions dans le plan de requête et les enregistre dans l'argument `solutions`. Les plans de requête commencent toujours par cette injection statique. Si des solutions statiques à injecter peuvent être dérivées de la requête proprement dite en combinant différentes sources de liaisons statiques (par exemple, à partir de clauses `VALUES` ou `BIND`), l'opérateur `SolutionInjection` injecte ces solutions statiques dérivées. Dans le cas le plus simple, elles reflètent des liaisons qui sont impliquées par une clause `VALUES` externe. Si aucune solution statique ne peut être dérivée à partir de la requête, `SolutionInjection` injecte la solution soit-disant universelle vide qui est étendue et multipliée tout au long du processus d'évaluation de requête. **Arguments** + `solutions` : (*obligatoire*) séquence de solutions injectées par l'opérateur. ## Opérateur `Sort` Trie l'ensemble de solutions à l'aide des conditions de tri spécifiées. **Arguments** + `sortOrder` : (*obligatoire*) liste ordonnée de variables, chacune contenant un élément `ASC` (croissant) ou `DESC` (décroissant), utilisées de manière séquentielle pour trier l'ensemble de solutions. ## Opérateur `VariableAlignment` Inspecte les solutions une par une, en alignant chacune d'entre elles sur deux variables : une variable `sourceVar` spécifiée et une variable `targetVar` spécifiée. Si `sourceVar` et `targetVar` dans une solution ont la même valeur, les variables sont considérées comme étant alignées et la solution est transmise avec les variables `sourceVar` redondantes sont projetées. Si les variables sont liées à des valeurs différentes, la solution est filtrée entièrement. **Arguments** + `sourceVar` : (*obligatoire*) variable source à comparer à la variable cible. Si l'alignement réussit dans une solution, ce qui signifie que les deux variables ont la même valeur, la variable source est projetée. + `targetVar` : (*obligatoire*) variable cible à laquelle la variable source est comparée. Elle est conservée même lorsque l'alignement réussit.