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à.
Esempi di chiamate di SPARQL explain in Neptune
Gli esempi di questa sezione mostrano i vari tipi di output che è possibile produrre richiamando la funzionalità SPARQL explain per analizzare l'esecuzione di query in Amazon Neptune.
Argomenti
Descrizione dell'output di Explain
In questo esempio, Jane Doe conosce due persone, ossia John Doe e Richard Roe:
@prefix ex: <http://example.com> . @prefix foaf: <http://xmlns.com/foaf/0.1/> . ex:JaneDoe foaf:knows ex:JohnDoe . ex:JohnDoe foaf:firstName "John" . ex:JohnDoe foaf:lastName "Doe" . ex:JaneDoe foaf:knows ex:RichardRoe . ex:RichardRoe foaf:firstName "Richard" . ex:RichardRoe foaf:lastName "Roe" . .
Per determinare i nomi di tutte le persone che Jane Doe conosce, puoi scrivere la seguente query:
curlhttp(s)://your_server:your_port/sparql \ -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \ SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \ -H "Accept: text/csv"
Questa query semplice restituisce il seguente risultato:
firstName John Richard
Quindi, modifica il comando curl per richiamare explain aggiungendo -d "explain=dynamic" e utilizzando il tipo di output predefinito invece di text/csv:
curlhttp(s)://your_server:your_port/sparql \ -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \ SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \ -d "explain=dynamic"
La query restituisce ora l'output in formato ASCII formattato (tipo di contenuto HTTP text/plain), che è il tipo di output predefinito:
╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗ ║ ID │ Out #1 │ Out #2 │ Name │ Arguments │ Mode │ Units In │ Units Out │ Ratio │ Time (ms) ║ ╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣ ║ 0 │ 1 │ - │ SolutionInjection │ solutions=[{}] │ - │ 0 │ 1 │ 0.00 │ 0 ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 1 │ 2 │ - │ PipelineJoin │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person) │ - │ 1 │ 2 │ 2.00 │ 1 ║ ║ │ │ │ │ joinType=join │ │ │ │ │ ║ ║ │ │ │ │ joinProjectionVars=[?person] │ │ │ │ │ ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 2 │ 3 │ - │ PipelineJoin │ pattern=distinct(?person, foaf:firstName, ?firstName) │ - │ 2 │ 2 │ 1.00 │ 1 ║ ║ │ │ │ │ joinType=join │ │ │ │ │ ║ ║ │ │ │ │ joinProjectionVars=[?person, ?firstName] │ │ │ │ │ ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 3 │ 4 │ - │ Projection │ vars=[?firstName] │ retain │ 2 │ 2 │ 1.00 │ 0 ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 4 │ - │ - │ TermResolution │ vars=[?firstName] │ id2value │ 2 │ 2 │ 1.00 │ 1 ║ ╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
Per ulteriori informazioni sulle operazioni nella colonna Name e i relativi argomenti, consulta Operatori explain.
Di seguito viene descritto l'output riga per riga:
-
La prima fase della query principale utilizza sempre l'operatore
SolutionInjectionper introdurre una soluzione. La soluzione viene quindi ampliata per il risultato finale attraverso il processo di valutazione.In questo caso, introduce la cosiddetta soluzione universale
{ }. In presenza di clausoleVALUESo unBIND, questa fase potrebbe anche introdurre associazioni di variabili più complesse per iniziare.La colonna
Units Outindica che questa è l'unica soluzione prodotta dall'operatore. La colonnaOut #1specifica l'operatore in cui questo operatore immette il risultato. In questo esempio, tutti gli operatori sono collegati all'operatore che segue nella tabella. -
La seconda fase è un
PipelineJoin. Riceve come input la soluzione universale (completamente non vincolata) unica prodotta dall'operatore precedente (Units In := 1). Esegue il join in base al modello di tupla definito dall'argomentopattern. Questo corrisponde a una semplice ricerca del modello. In questo caso, il modello triplice è definito come segue:distinct( ex:JaneDoe, foaf:knows, ?person )L'argomento
joinType := joinindica che questo è un join normale (altri tipi includono joinoptional,existence checke così via).L'argomento
distinct := trueindica che vengono estratte solo le corrispondenze distinte dal database (senza duplicati) e le corrispondenze distinte vengono associate alla variabilejoinProjectionVars := ?person, deduplicate.Il fatto che il valore della colonna
Units Outsia 2 indica che ci sono due soluzioni in uscita. Nello specifico, queste sono le associazioni per la variabile?person, riflettendo le due persone che i dati indicano che Jane Doe conosce:?person ------------- ex:JohnDoe ex:RichardRoe -
Le due soluzioni dalla fase 2 passano come input (
Units In := 2) al secondoPipelineJoin. Questo operatore esegue il join delle due soluzioni precedenti con il seguente modello triplice:distinct(?person, foaf:firstName, ?firstName)La variabile
?personè associata aex:JohnDoeo aex:RichardRoedalla soluzione in entrata dell'operatore. A questo punto,PipelineJoinestrae i nomi, John e Richard. Le due soluzioni in uscita (Units Out := 2) sono quindi le seguenti:?person | ?firstName --------------------------- ex:JohnDoe | John ex:RichardRoe | Richard -
Il successivo operatore di proiezione prende come input le due soluzioni dalla fase 3 (
Units In := 2) e le proietta alla variabile?firstName. Ciò elimina tutte le altre associazioni di variabili nelle mappature e inoltra le due associazioni (Units Out := 2):?firstName ---------- John Richard -
Per migliorare le prestazioni, Neptune opera ove possibile su identificatori interni assegnati a termini URIs come stringhe letterali, anziché sulle stringhe stesse. L'operatore finale,
TermResolution, esegue una mappatura da questi identificatori interni verso le stringhe di termini corrispondenti.In una valutazione di query regolare (non Explain), il risultato calcolato dall'ultimo operatore viene quindi serializzato nel formato di serializzazione richiesto e trasmesso al client.
Esempio di output con modalità dettagli
Nota
La modalità dettagli di SPARQL explain è disponibile a partire dal rilascio 1.0.2.1 del motore Neptune.
Si supponga di eseguire la stessa query precedente in modalità dettagli anziché in modalità dinamica:
curlhttp(s)://your_server:your_port/sparql \ -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \ SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \ -d "explain=details"
Come illustrato in questo esempio, l'output è lo stesso con alcuni dettagli aggiuntivi quali la stringa di query nella parte superiore dell'output e il conteggio patternEstimate per l'operatore PipelineJoin:
Query: PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName } ╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗ ║ ID │ Out #1 │ Out #2 │ Name │ Arguments │ Mode │ Units In │ Units Out │ Ratio │ Time (ms) ║ ╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣ ║ 0 │ 1 │ - │ SolutionInjection │ solutions=[{}] │ - │ 0 │ 1 │ 0.00 │ 0 ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 1 │ 2 │ - │ PipelineJoin │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person) │ - │ 1 │ 2 │ 2.00 │ 13 ║ ║ │ │ │ │ joinType=join │ │ │ │ │ ║ ║ │ │ │ │ joinProjectionVars=[?person] │ │ │ │ │ ║ ║ │ │ │ │ patternEstimate=2 │ │ │ │ │ ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 2 │ 3 │ - │ PipelineJoin │ pattern=distinct(?person, foaf:firstName, ?firstName) │ - │ 2 │ 2 │ 1.00 │ 3 ║ ║ │ │ │ │ joinType=join │ │ │ │ │ ║ ║ │ │ │ │ joinProjectionVars=[?person, ?firstName] │ │ │ │ │ ║ ║ │ │ │ │ patternEstimate=2 │ │ │ │ │ ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 3 │ 4 │ - │ Projection │ vars=[?firstName] │ retain │ 2 │ 2 │ 1.00 │ 1 ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 4 │ - │ - │ TermResolution │ vars=[?firstName] │ id2value │ 2 │ 2 │ 1.00 │ 7 ║ ╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
Esempio di output con modalità statica
Supponiamo di eseguire la stessa query precedente in modalità statica (impostazione predefinita) anziché in modalità dettagli:
curlhttp(s)://your_server:your_port/sparql \ -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \ SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \ -d "explain=static"
Come mostrato in questo esempio, l'output è lo stesso ma omette le ultime tre colonne:
╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╗ ║ ID │ Out #1 │ Out #2 │ Name │ Arguments │ Mode ║ ╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╣ ║ 0 │ 1 │ - │ SolutionInjection │ solutions=[{}] │ - ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢ ║ 1 │ 2 │ - │ PipelineJoin │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person) │ - ║ ║ │ │ │ │ joinType=join │ ║ ║ │ │ │ │ joinProjectionVars=[?person] │ ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢ ║ 2 │ 3 │ - │ PipelineJoin │ pattern=distinct(?person, foaf:firstName, ?firstName) │ - ║ ║ │ │ │ │ joinType=join │ ║ ║ │ │ │ │ joinProjectionVars=[?person, ?firstName] │ ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢ ║ 3 │ 4 │ - │ Projection │ vars=[?firstName] │ retain ║ ╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢ ║ 4 │ - │ - │ TermResolution │ vars=[?firstName] │ id2value ║ ╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╝
Diversi metodi di codifica dei parametri
Le query nell'esempio seguente illustrano due diversi metodi per codificare i parametri quando si richiama SPARQL explain.
Utilizzo di codifica URL: questo esempio utilizza la codifica URL dei parametri e specifica l'output dinamico:
curl -XGET "http(s)://your_server:your_port/sparql?query=SELECT%20*%20WHERE%20%7B%20%3Fs%20%3Fp%20%3Fo%20%7D%20LIMIT%20%31&explain=dynamic"
Specifica diretta dei parametri: questa è la stessa query precedente con la differenza che trasferisce i parametri direttamente tramite POST:
curlhttp(s)://your_server:your_port/sparql \ -d "query=SELECT * WHERE { ?s ?p ?o } LIMIT 1" \ -d "explain=dynamic"
Altri tipi di output oltre a text/plain
Gli esempi precedenti utilizzano il tipo di output predefinito text/plain. Neptune può anche formattare l'output di SPARQL explain in altri due formati di tipo MIME, vale a dire text/csv e text/html. È possibile richiamarli impostando l'intestazione Accept HTTP. A tale scopo, si può utilizzare il flag -H in curl, come segue:
-H "Accept:output type"
Ecco alcuni esempi:
Output text/csv
Questa query richiede l'output di tipo MIME CSV specificando -H "Accept: text/csv":
curlhttp(s)://your_server:your_port/sparql \ -d "query=SELECT * WHERE { ?s ?p ?o } LIMIT 1" \ -d "explain=dynamic" \ -H "Accept: text/csv"
Il formato CSV, che è utile per l'importazione in un foglio di calcolo o database, separa i campi in ogni riga explain con un punto e virgola ( ; ), come segue:
ID;Out #1;Out #2;Name;Arguments;Mode;Units In;Units Out;Ratio;Time (ms) 0;1;-;SolutionInjection;solutions=[{}];-;0;1;0.00;0 1;2;-;PipelineJoin;pattern=distinct(?s, ?p, ?o),joinType=join,joinProjectionVars=[?s, ?p, ?o];-;1;6;6.00;1 2;3;-;Projection;vars=[?s, ?p, ?o];retain;6;6;1.00;2 3;-;-;Slice;limit=1;-;1;1;1.00;1
Output text/html
Se si specifica -H "Accept: text/html", explain genera una tabella HTML:
<!DOCTYPE html> <html> <body> <table border="1px"> <thead> <tr> <th>ID</th> <th>Out #1</th> <th>Out #2</th> <th>Name</th> <th>Arguments</th> <th>Mode</th> <th>Units In</th> <th>Units Out</th> <th>Ratio</th> <th>Time (ms)</th> </tr> </thead> <tbody> <tr> <td>0</td> <td>1</td> <td>-</td> <td>SolutionInjection</td> <td>solutions=[{}]</td> <td>-</td> <td>0</td> <td>1</td> <td>0.00</td> <td>0</td> </tr> <tr> <td>1</td> <td>2</td> <td>-</td> <td>PipelineJoin</td> <td>pattern=distinct(?s, ?p, ?o)<br> joinType=join<br> joinProjectionVars=[?s, ?p, ?o]</td> <td>-</td> <td>1</td> <td>6</td> <td>6.00</td> <td>1</td> </tr> <tr> <td>2</td> <td>3</td> <td>-</td> <td>Projection</td> <td>vars=[?s, ?p, ?o]</td> <td>retain</td> <td>6</td> <td>6</td> <td>1.00</td> <td>2</td> </tr> <tr> <td>3</td> <td>-</td> <td>-</td> <td>Slice</td> <td>limit=1</td> <td>-</td> <td>1</td> <td>1</td> <td>1.00</td> <td>1</td> </tr> </tbody> </table> </body> </html>
L'HTML viene reso in un browser in modo simile al seguente:
Esempio di output di SPARQL explain quando è abilitato il motore DFE
Di seguito è riportato un esempio di output di SPARQL explain quando è abilitato il motore di query alternativo DFE:
╔════╤════════╤════════╤═══════════════════╤═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗ ║ ID │ Out #1 │ Out #2 │ Name │ Arguments │ Mode │ Units In │ Units Out │ Ratio │ Time (ms) ║ ╠════╪════════╪════════╪═══════════════════╪═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣ ║ 0 │ 1 │ - │ SolutionInjection │ solutions=[{}] │ - │ 0 │ 1 │ 0.00 │ 0 ║ ╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 1 │ 2 │ - │ HashIndexBuild │ solutionSet=solutionSet1 │ - │ 1 │ 1 │ 1.00 │ 22 ║ ║ │ │ │ │ joinVars=[] │ │ │ │ │ ║ ║ │ │ │ │ sourceType=pipeline │ │ │ │ │ ║ ╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 2 │ 3 │ - │ DFENode │ DFE Stats= │ - │ 101 │ 100 │ 0.99 │ 32 ║ ║ │ │ │ │ ====> DFE execution time (measured by DFEQueryEngine) │ │ │ │ │ ║ ║ │ │ │ │ accepted [micros]=127 │ │ │ │ │ ║ ║ │ │ │ │ ready [micros]=2 │ │ │ │ │ ║ ║ │ │ │ │ running [micros]=5627 │ │ │ │ │ ║ ║ │ │ │ │ finished [micros]=0 │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ ===> DFE execution time (measured in DFENode) │ │ │ │ │ ║ ║ │ │ │ │ -> setupTime [ms]=1 │ │ │ │ │ ║ ║ │ │ │ │ -> executionTime [ms]=14 │ │ │ │ │ ║ ║ │ │ │ │ -> resultReadTime [ms]=0 │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ ===> Static analysis statistics │ │ │ │ │ ║ ║ │ │ │ │ --> 35907 micros spent in parser. │ │ │ │ │ ║ ║ │ │ │ │ --> 7643 micros spent in range count estimation │ │ │ │ │ ║ ║ │ │ │ │ --> 2895 micros spent in value resolution │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ --> 39974925 micros spent in optimizer loop │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ DFEJoinGroupNode[ children={ │ │ │ │ │ ║ ║ │ │ │ │ DFEPatternNode[(?1, TERM[117442062], ?2, ?3) . project DISTINCT[?1, ?2] {rangeCountEstimate=100}, │ │ │ │ │ ║ ║ │ │ │ │ OperatorInfoWithAlternative[ │ │ │ │ │ ║ ║ │ │ │ │ rec=OperatorInfo[ │ │ │ │ │ ║ ║ │ │ │ │ type=INCREMENTAL_PIPELINE_JOIN, │ │ │ │ │ ║ ║ │ │ │ │ costEstimates=OperatorCostEstimates[ │ │ │ │ │ ║ ║ │ │ │ │ costEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0002,comp=0.0000,mem=0], │ │ │ │ │ ║ ║ │ │ │ │ worstCaseCostEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0002,comp=0.0000,mem=0]]], │ │ │ │ │ ║ ║ │ │ │ │ alt=OperatorInfo[ │ │ │ │ │ ║ ║ │ │ │ │ type=INCREMENTAL_HASH_JOIN, │ │ │ │ │ ║ ║ │ │ │ │ costEstimates=OperatorCostEstimates[ │ │ │ │ │ ║ ║ │ │ │ │ costEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0003,comp=0.0000,mem=3212], │ │ │ │ │ ║ ║ │ │ │ │ worstCaseCostEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0003,comp=0.0000,mem=3212]]]]], │ │ │ │ │ ║ ║ │ │ │ │ DFEPatternNode[(?1, TERM[150997262], ?4, ?5) . project DISTINCT[?1, ?4] {rangeCountEstimate=100}, │ │ │ │ │ ║ ║ │ │ │ │ OperatorInfoWithAlternative[ │ │ │ │ │ ║ ║ │ │ │ │ rec=OperatorInfo[ │ │ │ │ │ ║ ║ │ │ │ │ type=INCREMENTAL_HASH_JOIN, │ │ │ │ │ ║ ║ │ │ │ │ costEstimates=OperatorCostEstimates[ │ │ │ │ │ ║ ║ │ │ │ │ costEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0003,comp=0.0000,mem=6400], │ │ │ │ │ ║ ║ │ │ │ │ worstCaseCostEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0003,comp=0.0000,mem=6400]]], │ │ │ │ │ ║ ║ │ │ │ │ alt=OperatorInfo[ │ │ │ │ │ ║ ║ │ │ │ │ type=INCREMENTAL_PIPELINE_JOIN, │ │ │ │ │ ║ ║ │ │ │ │ costEstimates=OperatorCostEstimates[ │ │ │ │ │ ║ ║ │ │ │ │ costEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0010,comp=0.0000,mem=0], │ │ │ │ │ ║ ║ │ │ │ │ worstCaseCostEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0010,comp=0.0000,mem=0]]]]] │ │ │ │ │ ║ ║ │ │ │ │ }, │ │ │ │ │ ║ ║ │ │ │ │ ] │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ ===> DFE configuration: │ │ │ │ │ ║ ║ │ │ │ │ solutionChunkSize=5000 │ │ │ │ │ ║ ║ │ │ │ │ ouputQueueSize=20 │ │ │ │ │ ║ ║ │ │ │ │ numComputeCores=3 │ │ │ │ │ ║ ║ │ │ │ │ maxParallelIO=10 │ │ │ │ │ ║ ║ │ │ │ │ numInitialPermits=12 │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ ====> DFE configuration (reported back) │ │ │ │ │ ║ ║ │ │ │ │ numComputeCores=3 │ │ │ │ │ ║ ║ │ │ │ │ maxParallelIO=2 │ │ │ │ │ ║ ║ │ │ │ │ numInitialPermits=12 │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ ===> Statistics & operator histogram │ │ │ │ │ ║ ║ │ │ │ │ ==> Statistics │ │ │ │ │ ║ ║ │ │ │ │ -> 3741 / 3668 micros total elapsed (incl. wait / excl. wait) │ │ │ │ │ ║ ║ │ │ │ │ -> 3741 / 3 millis total elapse (incl. wait / excl. wait) │ │ │ │ │ ║ ║ │ │ │ │ -> 3741 / 0 secs total elapsed (incl. wait / excl. wait) │ │ │ │ │ ║ ║ │ │ │ │ ==> Operator histogram │ │ │ │ │ ║ ║ │ │ │ │ -> 47.66% of total time (excl. wait): pipelineScan (2 instances) │ │ │ │ │ ║ ║ │ │ │ │ -> 10.99% of total time (excl. wait): merge (1 instances) │ │ │ │ │ ║ ║ │ │ │ │ -> 41.17% of total time (excl. wait): symmetricHashJoin (1 instances) │ │ │ │ │ ║ ║ │ │ │ │ -> 0.19% of total time (excl. wait): drain (1 instances) │ │ │ │ │ ║ ║ │ │ │ │ │ │ │ │ │ ║ ║ │ │ │ │ nodeId | out0 | out1 | opName | args | rowsIn | rowsOut | chunksIn | chunksOut | elapsed* | outWait | outBlocked | ratio | rate* [M/s] | rate [M/s] | % │ │ │ │ │ ║ ║ │ │ │ │ ------ | ------ | ---- | ----------------- | ------------------------------------------------ | ------ | ------- | -------- | --------- | -------- | ------- | ---------- | -------- | ----------- | ---------- | ----- │ │ │ │ │ ║ ║ │ │ │ │ node_0 | node_2 | - | pipelineScan | (?1, TERM[117442062], ?2, ?3) DISTINCT [?1, ?2] | 0 | 100 | 0 | 1 | 874 | 0 | 0 | Infinity | 0.1144 | 0.1144 | 23.83 │ │ │ │ │ ║ ║ │ │ │ │ node_1 | node_2 | - | pipelineScan | (?1, TERM[150997262], ?4, ?5) DISTINCT [?1, ?4] | 0 | 100 | 0 | 1 | 874 | 0 | 0 | Infinity | 0.1144 | 0.1144 | 23.83 │ │ │ │ │ ║ ║ │ │ │ │ node_2 | node_4 | - | symmetricHashJoin | | 200 | 100 | 2 | 2 | 1510 | 73 | 0 | 0.50 | 0.0662 | 0.0632 | 41.17 │ │ │ │ │ ║ ║ │ │ │ │ node_3 | - | - | drain | | 100 | 0 | 1 | 0 | 7 | 0 | 0 | 0.00 | 0.0000 | 0.0000 | 0.19 │ │ │ │ │ ║ ║ │ │ │ │ node_4 | node_3 | - | merge | | 100 | 100 | 2 | 1 | 403 | 0 | 0 | 1.00 | 0.2481 | 0.2481 | 10.99 │ │ │ │ │ ║ ╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 3 │ 4 │ - │ HashIndexJoin │ solutionSet=solutionSet1 │ - │ 100 │ 100 │ 1.00 │ 4 ║ ║ │ │ │ │ joinType=join │ │ │ │ │ ║ ╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 4 │ 5 │ - │ Distinct │ vars=[?s, ?o, ?o1] │ - │ 100 │ 100 │ 1.00 │ 9 ║ ╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 5 │ 6 │ - │ Projection │ vars=[?s, ?o, ?o1] │ retain │ 100 │ 100 │ 1.00 │ 2 ║ ╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢ ║ 6 │ - │ - │ TermResolution │ vars=[?s, ?o, ?o1] │ id2value │ 100 │ 100 │ 1.00 │ 11 ║ ╚════╧════════╧════════╧═══════════════════╧═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
