Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
Ejemplos de invocación de explain de SPARQL en Neptune
Los ejemplos de esta sección muestran los diferentes tipos de salida que puede producir al invocar la característica explain de SPARQL para analizar la ejecución de consultas en Amazon Neptune.
Temas
Descripción de la salida de explain
En este ejemplo, Jane Doe conoce a dos personas, John Doe y 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" . .
Para determinar los nombres de todas las personas a las que conoce Jane Doe, puede escribir la siguiente consulta:
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"
Esta consulta sencilla devuelve lo siguiente:
firstName John Richard
A continuación, cambie el comando curl para invocar a explain añadiendo -d "explain=dynamic" y utilizando el tipo de salida predeterminado en lugar de 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 consulta ahora devuelve la salida en formato ASCII bien escrito (tipo de contenido HTTP text/plain), que es el tipo de salida predeterminado:
╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗ ║ 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 ║ ╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
Para obtener más información sobre las operaciones en la columna Name y sus argumentos, consulte Operadores explain.
A continuación, se describe la salida fila por fila:
-
El primer paso de la consulta principal siempre utiliza el operador
SolutionInjectionpara inyectar una solución. A continuación, la solución se expande al resultado final a través del proceso de evaluación.En este caso, se inyecta lo que se denomina la solución universal
{ }. En la presencia de cláusulasVALUESo un valorBIND, este paso también podría inyectar enlaces de variables más complejos para comenzar.La columna
Units Outindica que esta solución única fluye del operador. La columnaOut #1especifica el operador en el que este operador inyecta el resultado. En este ejemplo, todos los operadores están conectados al operador que se indica a continuación en la tabla. -
El segundo paso es un
PipelineJoin. Recibe como entrada la solución universal (sin restricciones) única producida por el operador anterior (Units In := 1). Lo une al patrón de tuplas definido por su argumentopattern. Esto corresponde a una búsqueda sencilla del patrón. En este caso, el patrón triple se define del modo siguiente:distinct( ex:JaneDoe, foaf:knows, ?person )El argumento
joinType := joinindica que esta es una unión normal (otros tipos incluyen unionesoptional,existence check, etc.).El argumento
distinct := truedice que solo se extraen coincidencias distintas de la base de datos (sin duplicados) y que dichas coincidencias se enlazan a la variablejoinProjectionVars := ?person, desduplicadas.El hecho de que el valor de la columna
Units Outsea 2 indica que hay dos soluciones fluyendo. En concreto, se trata de los enlaces para la variable?person, que reflejan las dos personas que los datos muestran que Jane Doe conoce:?person ------------- ex:JohnDoe ex:RichardRoe -
Las dos soluciones de la etapa 2 fluyen como entrada (
Units In := 2) en la segundaPipelineJoin. Este operador une las dos soluciones anteriores con el siguiente patrón triple:distinct(?person, foaf:firstName, ?firstName)Se sabe que la variable
?personestá enlazada aex:JohnDoeo aex:RichardRoepor la solución entrante del operador. Teniendo en cuenta esto,PipelineJoinextrae los nombres, John y Richard. Las dos soluciones salientes (Units Out := 2) son las siguientes:?person | ?firstName --------------------------- ex:JohnDoe | John ex:RichardRoe | Richard -
El siguiente operador de proyección toma como entrada la dos soluciones de la etapa 3 (
Units In := 2) y las proyecta en la variable?firstName. Esto elimina el resto de enlaces de variables en los mapeos y pasa los dos enlaces (Units Out := 2):?firstName ---------- John Richard -
Para mejorar el rendimiento, Neptune opera siempre que es posible con identificadores internos que asigna a términos como URI y literales de cadena, no con las propias cadenas. El operador final,
TermResolution, vuelve a mapear estos identificadores internos a las cadenas de términos correspondientes.En una evaluación de consulta normal (que no es de explain), el resultado calculado por el último operador se serializa en el formato de serialización solicitado y se transmite en streaming al cliente.
Ejemplo de salida del modo de detalles
nota
El modo de detalles de explain de SPARQL está disponible a partir de la versión 1.0.2.1 del motor de Neptune.
Supongamos que ejecuta la misma consulta que la anterior en modo de detalles en lugar de hacerlo en modo dinámico:
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"
Como muestra este ejemplo, la salida es la misma con algunos detalles adicionales como la cadena de consulta en la parte superior de la salida y el recuento de patternEstimate para el operador 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 ║ ╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
Ejemplo de salida del modo estático
Supongamos que ejecuta la consulta anterior en modo estático (el valor predeterminado) en lugar de en modo de detalles:
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"
Tal como muestra este ejemplo, el resultado es el mismo, salvo que omite las tres últimas columnas:
╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╗ ║ 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 ║ ╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╝
Distintas formas de codificar los parámetros
Las siguientes consultas de ejemplo ilustran dos formas distintas de codificar parámetros al invocar la característica explain de SPARQL.
Uso de la codificación URL: en este ejemplo, se utiliza la codificación URL de parámetros y se especifica la salida dinámica:
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"
Especificación de los parámetros directamente: es igual que en la consulta anterior, excepto que pasa los parámetros directamente a través de POST:
curlhttp(s)://your_server:your_port/sparql \ -d "query=SELECT * WHERE { ?s ?p ?o } LIMIT 1" \ -d "explain=dynamic"
Otros tipos de salida distintos de text/plain
Los ejemplos anteriores utilizan el tipo de salida text/plain predeterminado. Neptune también puede formatear la salida explain de SPARQL en otros dos formatos de tipo MIME, es decir, text/csv y text/html. Para invocarlos, establezca el encabezado HTTP Accept mediante la marca -H en curl, tal y como se indica a continuación:
-H "Accept:output type"
Estos son algunos ejemplos:
Salida text/csv
Esta consulta solicita un salida CSV de tipo MIME especificando -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"
El formato CSV, que resulta útil para la importación en una hoja de cálculo o una base de datos, separa los campos de cada fila de explain mediante punto y coma (;), de la siguiente manera:
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
Salida text/html
Si se especifica -H "Accept: text/html", explain genera una tabla 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>
El HTML representa en un navegador algo parecido a lo siguiente:
Ejemplo de salida explain de SPARQL cuando el DFE está habilitado
El siguiente es un ejemplo de una salida explain de SPARQ cuando el motor de consultas alternativo DFE de Neptune está habilitado:
╔════╤════════╤════════╤═══════════════════╤═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗ ║ 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 ║ ╚════╧════════╧════════╧═══════════════════╧═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
