Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Operatori di SPARQL `explain` in Neptune
Le seguenti sezioni descrivono gli operatori e i parametri per la funzionalità SPARQL `explain` attualmente disponibile in Amazon Neptune.
**Importante**
La funzione SPARQL `explain` è ancora in fase di definizione. Gli operatori e i parametri documentati qui potrebbero cambiare nelle prossime versioni.
**Topics**
+ [Operatore `Aggregation`](#sparql-explain-operator-aggregation)
+ [Operatore `ConditionalRouting`](#sparql-explain-operator-conditional-routing)
+ [Operatore `Copy`](#sparql-explain-operator-copy)
+ [Operatore `DFENode`](#sparql-explain-operator-dfenode)
+ [Operatore `Distinct`](#sparql-explain-operator-distinct)
+ [Operatore `Federation`](#sparql-explain-operator-federation)
+ [Operatore `Filter`](#sparql-explain-operator-filter)
+ [Operatore `HashIndexBuild`](#sparql-explain-operator-hash-index-build)
+ [Operatore `HashIndexJoin`](#sparql-explain-operator-hash-index-join)
+ [Operatore `MergeJoin`](#sparql-explain-operator-merge-join)
+ [Operatore `NamedSubquery`](#sparql-explain-operator-named-subquery)
+ [Operatore `PipelineJoin`](#sparql-explain-operator-pipeline-join)
+ [Operatore `PipelineCountJoin`](#sparql-explain-operator-pipeline-count-join)
+ [Operatore `PipelinedHashIndexJoin`](#sparql-explain-operator-pipeline-hash-index-join)
+ [Operatore `Projection`](#sparql-explain-operator-projection)
+ [Operatore `PropertyPath`](#sparql-explain-operator-property-path)
+ [Operatore `TermResolution`](#sparql-explain-operator-term-resolution)
+ [Operatore `Slice`](#sparql-explain-operator-slice)
+ [Operatore `SolutionInjection`](#sparql-explain-operator-solution-injection)
+ [Operatore `Sort`](#sparql-explain-operator-sort)
+ [Operatore `VariableAlignment`](#sparql-explain-operator-variable-alignment)
## Operatore `Aggregation`
Esegue una o più aggregazioni, implementando la semantica di operatori di aggregazione SPARQL, come `count`, `max`, `min`, `sum` e così via.
`Aggregation` viene fornito con il raggruppamento opzionale utilizzando le clausole `groupBy` e i vincoli opzionali `having`.
**Arguments (Argomenti)**
+ `groupBy`: (*facoltativo*) fornisce una clausola `groupBy` che specifica la sequenza di espressioni in base a cui le soluzioni in entrata sono raggruppate.
+ `aggregates`: (*obbligatorio*) specifica un elenco ordinato di espressioni di aggregazione.
+ `having`: (*facoltativo*) aggiunge vincoli per filtrare gruppi, come implicito nella clausola `having` della query SPARQL.
## Operatore `ConditionalRouting`
Instrada le soluzioni in entrata in base a una determinata condizione. Le soluzioni che soddisfano la condizione vengono instradate all'ID operatore a cui fa riferimento `Out #1`, mentre le soluzioni che non la soddisfano vengono instradate all'operatore a cui fa riferimento `Out #2`.
**Arguments (Argomenti)**
+ `condition`: (*obbligatorio*) la condizione di instradamento.
## Operatore `Copy`
Delega il flusso di soluzione come specificato dalla modalità indicata.
**Modalità**
+ `forward`: inoltra le soluzioni all'operatore downstream identificato da `Out #1`.
+ `duplicate`: duplica le soluzioni e le inoltra a ciascuno dei due operatori identificati da `Out #1` e `Out #2`.
`Copy` non ha argomenti.
## Operatore `DFENode`
Questo operatore è un'astrazione del piano eseguito dal motore di query alternativo DFE. Il piano DFE dettagliato è illustrato negli argomenti di questo operatore. L'argomento è attualmente sovraccarico per contenere le statistiche dettagliate di runtime del piano DFE. Contiene il tempo impiegato nei vari passaggi di esecuzione delle query da parte del motore DFE.
L'albero sintattico astratto (AST) logico ottimizzato per il piano di query DFE viene stampato con informazioni sui tipi di operatori presi in considerazione durante la pianificazione e sui costi associati nel caso peggiore e nel caso migliore per l'esecuzione degli operatori. Al momento, l'AST è composto dai seguenti tipi di nodi:
+ `DFEJoinGroupNode`: rappresenta un join di uno o più `DFEPatternNodes`.
+ `DFEPatternNode`: incapsula un modello sottostante con cui le tuple corrispondenti vengono proiettate fuori dal database sottostante.
La sottosezione `Statistics & Operator histogram` contiene dettagli sul tempo di esecuzione del piano `DataflowOp` e sulla ripartizione del tempo di CPU utilizzato da ciascun operatore. Di seguito è riportata una tabella che riporta le statistiche dettagliate di runtime del piano eseguito dal motore DFE.
**Nota**
Poiché il supporto DFE per SPARQL è una funzionalità sperimentale, il formato esatto del relativo output potrebbe cambiare. `explain`
## Operatore `Distinct`
Calcola la proiezione Distinct su un sottoinsieme di variabili, eliminando i duplicati. Di conseguenza, il numero di soluzioni in entrata è maggiore o uguale al numero di soluzioni in uscita.
**Arguments (Argomenti)**
+ `vars`: (*obbligatorio*) variabili a cui si applica la proiezione `Distinct`.
## Operatore `Federation`
Passa una determinata query a un endpoint SPARQL remoto specifico.
**Arguments (Argomenti)**
+ `endpoint`: (*obbligatorio*) URL dell'endpoint nella dichiarazione SPARQL `SERVICE`. Può essere una stringa costante oppure, se l'endpoint della query è determinato in base a una variabile all'interno della stessa query, il nome della variabile.
+ `query`: (*obbligatorio*) stringa di query ricostruita da inviare all'endpoint remoto. Il motore aggiunge prefissi predefiniti a questa query anche quando non vengono specificati dal client.
+ `silent`: (*obbligatorio*) valore booleano che indica se la parola chiave `SILENT` è visualizzata dopo la parola chiave. `SILENT` indica al motore di non considerare tutta la query non riuscita anche se la parte `SERVICE` remota non riesce.
## Operatore `Filter`
Filtra le soluzioni in entrata. Solo le soluzioni che soddisfano la condizione di filtro vengono inoltrate all'operatore upstream, mentre le altre vengono rilasciate.
**Arguments (Argomenti)**
+ `condition`: (*obbligatorio*) condizione di filtro.
## Operatore `HashIndexBuild`
Prende un elenco di associazioni e le elabora in un indice hash il cui nome viene definito dall'argomento `solutionSet`. Di solito, gli operatori successivi eseguono join in base a questo set di soluzioni, facendovi riferimento con quel nome.
**Arguments (Argomenti)**
+ `solutionSet`: (*obbligatorio*) nome del set di soluzioni dell'indice hash.
+ `sourceType`: (*obbligatorio*) tipo di origine da cui vengono ottenute le associazioni da archiviare nell'indice hash.
+ `pipeline`: elabora le soluzioni in entrata dall'operatore downstream nella pipeline dell'operatore nell'indice hash.
+ `binding set`: elabora il set di associazioni fisse specificate dall'argomento `sourceBindingSet` nell'indice hash.
+ `sourceBindingSet`: (*facoltativo*) se il valore dell'argomento `sourceType` è `binding set`, questo argomento specifica il set di associazioni statico da elaborare nell'indice hash.
## Operatore `HashIndexJoin`
Esegue il join delle soluzioni in entrata rispetto al set di soluzioni dell'indice hash identificato dall'argomento `solutionSet`.
**Arguments (Argomenti)**
+ `solutionSet`: (*obbligatorio*) nome del set di soluzioni rispetto al quale eseguire il join. Questo deve essere un indice hash che è stato costruito in una fase precedente utilizzando l'operatore `HashIndexBuild`.
+ `joinType`: (*obbligatorio*) tipo di join da eseguire.
+ `join`: join normale che richiede una corrispondenza esatta tra tutte le variabili condivise.
+ `optional`: join `optional` che usa la semantica dell'operatore SPARQL `OPTIONAL`.
+ `minus`: un'operazione `minus` conserva una mappatura per la quale non esiste alcun partner di join, utilizzando la semantica dell'operatore SPARQL `MINUS`.
+ `existence check`: verifica se c'è un partner di join o meno e associa la variabile `existenceCheckResultVar` al risultato di questo controllo.
+ `constraints`: (*facoltativo*) vincoli di join aggiuntivi considerati durante il join. I join che non soddisfano questi vincoli vengono eliminati.
+ `existenceCheckResultVar`: (*facoltativo*) usato solo per i join in cui `joinType` è uguale a `existence check` (vedi l'argomento `joinType` precedente).
## Operatore `MergeJoin`
Un merge join su più set di soluzioni, identificati dall'argomento `solutionSets`.
**Arguments (Argomenti)**
+ `solutionSets`: (*obbligatorio*) set di soluzioni su cui eseguire il join.
## Operatore `NamedSubquery`
Attiva la valutazione della sottoquery identificata dall'argomento `subQuery` ed elabora il risultato nel set di soluzioni specificato dall'argomento `solutionSet`. Le soluzioni in entrata per l'operatore sono inoltrate alla sottoquery e quindi all'operatore successivo.
**Arguments (Argomenti)**
+ `subQuery`: (*obbligatorio*) nome della sottoquery da valutare. La sottoquery viene resa in modo esplicito nell'output.
+ `solutionSet`: (*obbligatorio*) nome del set di soluzioni in cui archiviare il risultato della sottoquery.
## Operatore `PipelineJoin`
Riceve come input l'output dell'operatore precedente ed esegue il join in base al modello di tupla definito dall'argomento `pattern`.
**Arguments (Argomenti)**
+ `pattern`— (*Obbligatorio*) Il pattern, che assume la forma di una tupla subject-predicate-object, e facoltativamente di un grafico, che sta alla base dell'unione. Se `distinct` viene specificato per il modello, il join estrae solo le soluzioni distinte dalle variabili di proiezione specificate dall'argomento `projectionVars`, piuttosto che tutte le soluzioni corrispondenti.
+ `inlineFilters`: (*facoltativo*) set di filtri da applicare alle variabili nel modello. Il modello viene valutato in combinazione con questi filtri.
+ `joinType`: (*obbligatorio*) tipo di join da eseguire.
+ `join`: join normale che richiede una corrispondenza esatta tra tutte le variabili condivise.
+ `optional`: join `optional` che usa la semantica dell'operatore SPARQL `OPTIONAL`.
+ `minus`: un'operazione `minus` conserva una mappatura per la quale non esiste alcun partner di join, utilizzando la semantica dell'operatore SPARQL `MINUS`.
+ `existence check`: verifica se c'è un partner di join o meno e associa la variabile `existenceCheckResultVar` al risultato di questo controllo.
+ `constraints`: (*facoltativo*) vincoli di join aggiuntivi considerati durante il join. I join che non soddisfano questi vincoli vengono eliminati.
+ `projectionVars`: (*facoltativo*) variabili della proiezione. Utilizzato in combinazione con `distinct := true` per applicare l'estrazione delle proiezioni distinte per un determinato set di variabili.
+ `cutoffLimit`: (*facoltativo*) limite massimo per il numero di partner di join estratti. Anche se non vi è alcun limite predefinito, è possibile impostare questo a 1 quando si eseguono join per implementare clausole `FILTER (NOT) EXISTS`, dove è sufficiente provare o smentire che c'è un partner di join.
## Operatore `PipelineCountJoin`
Variante di `PipelineJoin`. Invece di eseguire il join, conteggia solo i partner di join corrispondenti e associa il conteggio alla variabile specificata dall'argomento `countVar`.
**Arguments (Argomenti)**
+ `countVar`: (*obbligatorio*) variabile a cui il risultato del conteggio, cioè il numero di partner di join, deve essere associato.
+ `pattern`— (*Obbligatorio*) Il pattern, che assume la forma di una tupla subject-predicate-object, e facoltativamente a grafo, che sta alla base dell'unione. Se `distinct` viene specificato per il modello, il join estrae solo le soluzioni distinte dalle variabili di proiezione specificate dall'argomento `projectionVars`, piuttosto che tutte le soluzioni corrispondenti.
+ `inlineFilters`: (*facoltativo*) set di filtri da applicare alle variabili nel modello. Il modello viene valutato in combinazione con questi filtri.
+ `joinType`: (*obbligatorio*) tipo di join da eseguire.
+ `join`: join normale che richiede una corrispondenza esatta tra tutte le variabili condivise.
+ `optional`: join `optional` che usa la semantica dell'operatore SPARQL `OPTIONAL`.
+ `minus`: un'operazione `minus` conserva una mappatura per la quale non esiste alcun partner di join, utilizzando la semantica dell'operatore SPARQL `MINUS`.
+ `existence check`: verifica se c'è un partner di join o meno e associa la variabile `existenceCheckResultVar` al risultato di questo controllo.
+ `constraints`: (*facoltativo*) vincoli di join aggiuntivi considerati durante il join. I join che non soddisfano questi vincoli vengono eliminati.
+ `projectionVars`: (*facoltativo*) variabili della proiezione. Utilizzato in combinazione con `distinct := true` per applicare l'estrazione delle proiezioni distinte per un determinato set di variabili.
+ `cutoffLimit`: (*facoltativo*) limite massimo per il numero di partner di join estratti. Anche se non vi è alcun limite predefinito, è possibile impostare questo a 1 quando si eseguono join per implementare clausole `FILTER (NOT) EXISTS`, dove è sufficiente provare o smentire che c'è un partner di join.
## Operatore `PipelinedHashIndexJoin`
Si tratta di un operatore di all-in-one build hash index e join. Accetta un elenco di associazioni, le elabora in un indice hash e quindi esegue il join delle soluzioni in entrata rispetto all'indice hash.
**Arguments (Argomenti)**
+ `sourceType`: (*obbligatorio*) tipo di origine da cui vengono ottenute le associazioni da archiviare nell'indice hash, uno tra:
+ `pipeline`: fa sì che `PipelinedHashIndexJoin` elabori le soluzioni in entrata dall'operatore downstream nella pipeline dell'operatore nell'indice hash.
+ `binding set`: fa sì che `PipelinedHashIndexJoin` elabori il set di associazioni fisse specificate dall'argomento `sourceBindingSet` nell'indice hash.
+ `sourceSubQuery `: (*facoltativo*) se il valore dell'argomento `sourceType` è `pipeline`, questo argomento specifica la sottoquery che viene valutata ed elaborata nell'indice hash.
+ `sourceBindingSet `: (*facoltativo*) se il valore dell'argomento `sourceType` è `binding set`, questo argomento specifica il set di associazioni statico da elaborare nell'indice hash.
+ `joinType`: (*obbligatorio*) tipo di join da eseguire:
+ `join`: join normale che richiede una corrispondenza esatta tra tutte le variabili condivise.
+ `optional`: join `optional` che usa la semantica dell'operatore SPARQL `OPTIONAL`.
+ `minus`: un'operazione `minus` conserva una mappatura per la quale non esiste alcun partner di join, utilizzando la semantica dell'operatore SPARQL `MINUS`.
+ `existence check`: verifica se c'è un partner di join o meno e associa la variabile `existenceCheckResultVar` al risultato di questo controllo.
+ `existenceCheckResultVar`: (*facoltativo*) usato solo per i join in cui `joinType` è uguale a `existence check` (vedi l'argomento joinType precedente).
## Operatore `Projection`
Proietta su un sottoinsieme di variabili. Il numero di soluzioni in entrata è uguale al numero di soluzioni in uscita, ma la forma della soluzione varia in base all'impostazione della modalità.
**Modalità**
+ `retain`: conserva nelle soluzioni solo le variabili specificate dall'argomento `vars`.
+ `drop`: elimina tutte le variabili specificate dall'argomento `vars`.
**Arguments (Argomenti)**
+ `vars`: (*obbligatorio*) variabili da conservare o eliminare, a seconda dell'impostazione della modalità.
## Operatore `PropertyPath`
Abilita percorsi di proprietà ricorsivi come `+` o `*`. Neptune implementa un approccio di iterazione a virgola fissa in base a un modello specificato dall'argomento `iterationTemplate`. Le variabili lato destro o lato sinistro note sono vincolate nel modello per ogni iterazione a virgola fissa, fino a quando non vengono più trovate nuove soluzioni.
**Arguments (Argomenti)**
+ `iterationTemplate`: (*obbligatorio*) nome del modello di sottoquery utilizzato per implementare l'iterazione a virgola fissa.
+ `leftTerm`: (*obbligatorio*) termine (variabile o costante) sul lato sinistro del percorso di proprietà.
+ `rightTerm`: (*obbligatorio*) termine (variabile o costante) sul lato destro del percorso di proprietà.
+ `lowerBound`: (*obbligatorio*) limite inferiore per l'iterazione a virgola fissa (`0` per le query `*` oppure `1` per le query `+`).
## Operatore `TermResolution`
Traduce i valori dell'identificatore della stringa interna nelle stringhe esterni corrispondenti o traduce le stringhe esterne in valori dell'identificatore della stringa interna, in base alla modalità.
**Modalità**
+ `value2id`— Associa termini come valori letterali e URIs ai corrispondenti valori ID interni (codifica in valori interni).
+ `id2value`— Associa i valori ID interni ai termini corrispondenti, ad esempio letterali e URIs (decodifica dei valori interni).
**Arguments (Argomenti)**
+ `vars`— (*Obbligatorio*) Specificate le variabili le cui stringhe o stringhe interne devono essere mappate. IDs
## Operatore `Slice`
Implementa una sezione nel flusso di soluzioni in entrata, utilizzando la semantica delle clausole SPARQL `LIMIT` e `OFFSET`.
**Arguments (Argomenti)**
+ `limit`: (*facoltativo*) limite per le soluzioni da inoltrare.
+ `offset`: (*facoltativo*) offset a cui sono valutate le soluzioni per l'inoltro.
## Operatore `SolutionInjection`
Non riceve alcun input. Introduce staticamente le soluzioni nel piano di query e le registra nell'argomento `solutions`.
I piani di query iniziano sempre con questa introduzione statica. Se le soluzioni statiche da introdurre possono essere ricavate dalla query stessa combinando varie origini di associazioni statiche (ad esempio da clausole `VALUES` o `BIND`), l'operatore `SolutionInjection` introduce queste soluzioni statiche derivate. Nel caso più semplice, queste riflettono associazioni che sono implicite in una clausola `VALUES` esterna.
Se nessuna delle soluzioni statiche può essere ricavata dalla query, `SolutionInjection` introduce la soluzione vuota cosiddetta universale, che viene ampliata e moltiplicata durante tutto il processo di valutazione di query.
**Arguments (Argomenti)**
+ `solutions`: (*obbligatorio*) sequenza di soluzioni introdotte dall'operatore.
## Operatore `Sort`
Ordina il set di soluzioni utilizzando le condizioni di ordinamento specificate.
**Arguments (Argomenti)**
+ `sortOrder`: (*obbligatorio*) elenco ordinato di variabili, ognuna contenente un identificatore `ASC` (crescente) o `DESC` (decrescente), utilizzate sequenzialmente per ordinare il set di soluzioni.
## Operatore `VariableAlignment`
Analizza le soluzioni una ad una, eseguendo l'allineamento su ognuna in base a due variabili: un `sourceVar` specificato e un `targetVar` specificato.
Se `sourceVar` e `targetVar` in una soluzione hanno lo stesso valore, le variabili sono considerate allineate e la soluzione viene inoltrata, con il `sourceVar` ridondante proiettato in uscita.
Se le variabili sono associate a diversi valori, la soluzione viene completamente filtrata.
**Arguments (Argomenti)**
+ `sourceVar`: (*obbligatorio*) variabile di origine da confrontare con la variabile di destinazione. Se l'allineamento va a buon fine in una soluzione, il che significa che le due variabili hanno lo stesso valore, la variabile di origine viene proiettata in uscita.
+ `targetVar`: (*obbligatorio*) variabile di destinazione con la quale viene confrontata la variabile di origine. Viene conservata anche quando l'allineamento va a buon fine.