diff --git a/modules/ROOT/content-nav.adoc b/modules/ROOT/content-nav.adoc index 6b1add734..b82e15537 100644 --- a/modules/ROOT/content-nav.adoc +++ b/modules/ROOT/content-nav.adoc @@ -119,3 +119,6 @@ * Appendix ** xref:styleguide.adoc[] ** xref:appendix/tutorials/index.adoc[] +*** xref:appendix/tutorials/basic-query-tuning.adoc[] +*** xref:appendix/tutorials/advanced-query-tuning.adoc[] +*** xref:appendix/tutorials/shortestpath-planning.adoc[] diff --git a/modules/ROOT/pages/clauses/listing-settings.adoc b/modules/ROOT/pages/clauses/listing-settings.adoc index bc05e39af..6dcf48a42 100644 --- a/modules/ROOT/pages/clauses/listing-settings.adoc +++ b/modules/ROOT/pages/clauses/listing-settings.adoc @@ -227,6 +227,10 @@ LIMIT 10 | "20s" | "Time out for protocol negotiation handshake." +| "dbms.cluster.network.connect_timeout" +| "30s" +| "The maximum amount of time to wait for a network connection to be established." + | "dbms.cluster.network.max_chunk_size" | "32768" | "Maximum chunk size allowable across network by clustering machinery." @@ -235,10 +239,6 @@ LIMIT 10 | "" | "Network compression algorithms that this instance will allow in negotiation as a comma-separated list. Listed in descending order of preference for incoming connections. An empty list implies no compression. For outgoing connections this merely specifies the allowed set of algorithms and the preference of the remote peer will be used for making the decision. Allowable values: [Gzip, Snappy, Snappy_validating, LZ4, LZ4_high_compression, LZ_validating, LZ4_high_compression_validating]" -| "dbms.cluster.raft.binding_timeout" -| "1d" -| "The time allowed for a database on a Neo4j server to either join a cluster or form a new cluster with at least the quorum of the members available. The members are provided by `dbms.cluster.discovery.endpoints` for the system database and by the topology graph for user databases." - 3+d|Rows: 10 |=== diff --git a/modules/ROOT/pages/clauses/order-by.adoc b/modules/ROOT/pages/clauses/order-by.adoc index af3afcc60..d71bd51e8 100644 --- a/modules/ROOT/pages/clauses/order-by.adoc +++ b/modules/ROOT/pages/clauses/order-by.adoc @@ -240,4 +240,4 @@ This rule is to make sure that `ORDER BY` does not change the results, only the The performance of Cypher queries using `ORDER BY` on node properties can be influenced by the existence and use of an index for finding the nodes. If the index can provide the nodes in the order requested in the query, Cypher can avoid the use of an expensive `Sort` operation. -Read more about this capability in xref::appendix/tutorials/advanced-query-tuning.adoc#advanced-query-tuning-example-index-backed-order-by[Index-backed ORDER BY]. +Read more about this capability in xref::indexes/search-performance-indexes/using-indexes.adoc#range-index-backed-order-by[Range index-backed ORDER BY]. diff --git a/modules/ROOT/pages/clauses/use.adoc b/modules/ROOT/pages/clauses/use.adoc index b3a6ad5fd..e76a65e97 100644 --- a/modules/ROOT/pages/clauses/use.adoc +++ b/modules/ROOT/pages/clauses/use.adoc @@ -27,7 +27,7 @@ Where `` refers to the name or alias of a database in the DBMS. [[query-use-syntax-composite]] === Composite database syntax -When running queries against a link:{neo4j-docs-base-uri}/operations-manual/{page-version}/composite-databases[composite database], the `USE` clause can also appear as the first clause of: +When running queries against a link:{neo4j-docs-base-uri}/operations-manual/{page-version}/database-administration/composite-databases/concepts/[composite database], the `USE` clause can also appear as the first clause of: * Union parts: + diff --git a/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc b/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc index 004793e7c..0a47d3de7 100644 --- a/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc +++ b/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc @@ -55,6 +55,34 @@ RETURN "string" IS NORMALIZED | Introduction of an xref::syntax/operators.adoc#match-string-is-normalized[IS NORMALIZED] operator. The operator can be used to check if a `STRING` is normalized according to the specified normalization form, which can be of type `NFC`, `NFD`, `NFKC`, or `NFKD`. +a| +label:functionality[] +label:new[] + +New operators: + +* xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-all-nodes-scan[`PartitionedAllNodesScan`] +* xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-all-relationships-scan[`PartitionedDirectedAllRelationshipsScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-relationship-index-scan[`PartitionedDirectedRelationshipIndexScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-relationship-index-seek[`PartitionedDirectedRelationshipIndexSeek`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-relationship-index-seek-by-range[`PartitionedDirectedRelationshipIndexSeekByRange`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-union-relationship-types-scan[`PartitionedDirectedUnionRelationshipTypesScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-by-label-scan[`PartitionedNodeByLabelScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-index-scan[`PartitionedNodeIndexScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-index-seek[`PartitionedNodeIndexSeek`] +* xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-index-seek-by-range[`PartitionedNodeIndexSeekByRange`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-all-relationships-scan[`PartitionedUndirectedAllRelationshipsScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-relationship-index-scan[`PartitionedUndirectedRelationshipIndexScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-relationship-index-seek[`PartitionedUndirectedRelationshipIndexSeek`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-relationship-index-seek-by-range[`PartitionedUndirectedRelationshipIndexSeekByRange`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-relationship-type-scan[`PartitionedUndirectedRelationshipTypeScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-union-relationship-types-scan[`PartitionedUndirectedUnionRelationshipTypesScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-union-node-by-labels-scan[`PartitionedUnionNodeByLabelsScan`] +* xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-unwind[`PartitionedUnwind`] + +| Introduction of partitioned operators used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +These operators segment the data and operate on each segment in parallel + |=== [[cypher-deprecations-additions-removals-5.16]] diff --git a/modules/ROOT/pages/patterns/concepts.adoc b/modules/ROOT/pages/patterns/concepts.adoc index 24ea0a0e2..3715e8894 100644 --- a/modules/ROOT/pages/patterns/concepts.adoc +++ b/modules/ROOT/pages/patterns/concepts.adoc @@ -836,7 +836,6 @@ RETURN [n in nodes(p) | n.name] AS stops |=== On a large, highly connected graph, this can be very time consuming. -See the section on xref::appendix/tutorials/shortestpath-planning.adoc[shortest path planning] for more information. [[shortest-path-all-shortest-paths]] === All shortest paths diff --git a/modules/ROOT/pages/patterns/reference.adoc b/modules/ROOT/pages/patterns/reference.adoc index e3d81a82b..e7688332c 100644 --- a/modules/ROOT/pages/patterns/reference.adoc +++ b/modules/ROOT/pages/patterns/reference.adoc @@ -760,6 +760,11 @@ upperBound ::= unsignedInteger unsignedInteger ::= [0-9]+ ---- +[NOTE] +==== +The `unsignedInteger` must not be larger than the Java constant `Long.MAX_VALUE` (2^63-1). +==== + [[quantifiers-rules]] === Rules @@ -1104,6 +1109,11 @@ upperBound ::= unsignedInteger unsignedInteger ::= [0-9]+ ---- +[NOTE] +==== +The `unsignedInteger` must not be larger than the Java constant `Long.MAX_VALUE` (2^63-1). +==== + For rules on valid relationship variable names, see xref:syntax/naming.adoc[Cypher naming rules]. [[variable-length-relationships-rules]] diff --git a/modules/ROOT/pages/planning-and-tuning/operators/index.adoc b/modules/ROOT/pages/planning-and-tuning/operators/index.adoc index 49c8fa1ed..8377afabb 100644 --- a/modules/ROOT/pages/planning-and-tuning/operators/index.adoc +++ b/modules/ROOT/pages/planning-and-tuning/operators/index.adoc @@ -471,6 +471,130 @@ It is not eager. | | +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-all-nodes-scan[PartitionedAllNodesScan] +| Used by the parallel runtime to read all nodes from the node store. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-all-relationships-scan[PartitionedDirectedAllRelationshipsScan] +| Used by the parallel runtime to fetch all relationships and their start and end nodes from the database. +| label:yes[] +| +| label:new[Introduced in 5.17] + + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-relationship-index-scan[PartitionedDirectedRelationshipIndexScan] +| Used by the parallel runtime to examine all values stored in an index. +It returns all relationships with a particular type and a specified property, along with their start and end nodes. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-relationship-index-seek[PartitionedDirectedRelationshipIndexSeek] +| Finds relationships and their start and end nodes using a parallel index seek. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-relationship-index-seek-by-range[PartitionedDirectedRelationshipIndexSeekByRange] +| Finds relationships using a parallel index seek where the value of the of the specified relationship type property is within a given range. +It also finds the start and end nodes of those relationships. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-relationship-types-scan[PartitionedDirectedRelationshipTypesScan] +| Fetches all relationships with a specific type from the relationship type index using a parallel scan. +It also fetches the start and end nodes of those relationships. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-directed-union-relationship-types-scan[PartitionedDirectedUnionRelationshipTypesScan] +| Fetches all relationships with at least one of the provided types from the relationship type index using a parallel scan. +It also fetches the start and end nodes of those relationships. +| +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-by-label-scan[PartitionedNodeByLabelScan] +| Used by the parallel runtime to fetch all nodes with a specific label from the node label index. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-index-scan[PartitionedNodeIndexScan] +| Used by the parallel runtime to examine all values stored in an index, returning all nodes with a particular label and a specified property. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-index-seek[PartitionedNodeIndexSeek] +| Used by the parallel runtime to find nodes using an index seek. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-index-seek-by-range[PartitionedNodeIndexSeekByRange] +| Finds nodes using a parallel index seek where the value of the specified property is within a given range. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-all-relationships-scan[PartitionedUndirectedAllRelationshipsScan] +| Used by the parallel runtime to fetch all relationships and their start and end nodes from the database. +| label:yes[] +| +| label:new[Introduced in 5.17] + + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-relationship-index-scan[PartitionedUndirectedRelationshipIndexScan] +| Used by the parallel runtime to examine all values stored in an index, returning all relationships with a particular relationship type and a specified property. +It also returns the start and end nodes of those relationships. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-relationship-index-seek[PartitionedUndirectedRelationshipIndexSeek] +| Finds relationships and their start and end nodes using a parallel index seek. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-relationship-index-seek-by-range[PartitionedUndirectedRelationshipIndexSeekByRange] +| Finds relationships using a parallel index seek where the value of the specified relationship property type is within a given range. +It also finds the start and end nodes of those relationships. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-relationship-type-scan[PartitionedUndirectedRelationshipTypeScan] +| Used by the parallel runtime to fetch all relationships with a specific type from the relationship type index. +It also fetches the start and end nodes of those relationships. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-undirected-union-relationship-types-scan[PartitionedUndirectedUnionRelationshipTypesScan] +| Used by the parallel runtime to fetch all relationships with at least one of the provided types from the relationship type index. +It also fetches the start and end nodes of those relationships. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-union-node-by-labels-scan[PartitionedUnionNodeByLabelsScan] +| Used by the parallel runtime to fetch all nodes that have at least one of the provided labels from the node label index. +| label:yes[] +| +| label:new[Introduced in 5.17] + +| xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-unwind[PartitionedUnwind] +| Used by the parallel runtime to return one row per item in a list. +| +| +| label:new[Introduced in 5.17] + | xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-procedure-call[ProcedureCall] | Calls a procedure. | diff --git a/modules/ROOT/pages/planning-and-tuning/operators/operators-detail.adoc b/modules/ROOT/pages/planning-and-tuning/operators/operators-detail.adoc index 4bdb22226..250e207d7 100644 --- a/modules/ROOT/pages/planning-and-tuning/operators/operators-detail.adoc +++ b/modules/ROOT/pages/planning-and-tuning/operators/operators-detail.adoc @@ -125,6 +125,53 @@ Total database accesses: 36, total allocated memory: 184 ====== +[[query-plan-partitioned-all-nodes-scan]] +== Partitioned All Nodes Scan +// PartitionedAllNodesScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + + +The `PartitionedAllNodesScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-all-nodes-scan[`AllNodesScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the store to be partitioned into different segments where each segment can be scanned independently in parallel. + +.PartitionedAllNodesScan +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (n) +RETURN n +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++--------------------------+----+---------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++--------------------------+----+---------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | n | 35 | 35 | 71 | 2/0 | 6.470 | In Pipeline 1 | +| | +----+---------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedAllNodesScan | 1 | n | 35 | 35 | 35 | 3/0 | 1.491 | In Pipeline 0 | ++--------------------------+----+---------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 106 +---- + +====== + [[query-plan-directed-relationship-index-scan]] == Directed Relationship Index Scan @@ -176,6 +223,53 @@ Total database accesses: 16, total allocated memory: 184 ====== +[[query-plan-partitioned-directed-relationship-index-scan]] +== Partitioned Directed Relationship Index Scan +// PartitionedDirectedRelationshipIndexScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + + +The `PartitionedDirectedRelationshipIndexScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-directed-relationship-index-scan[`DirectedRelationshipIndexScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + +.PartitionedDirectedRelationshipIndexScan +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH ()-[r: WORKS_IN]->() +WHERE r.title IS NOT NULL +RETURN r +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++-------------------------------------------+----+----------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++-------------------------------------------+----+----------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | r | 15 | 15 | 70 | 1/0 | 2.865 | In Pipeline 1 | +| | +----+----------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedDirectedRelationshipIndexScan | 1 | RANGE INDEX (anon_0)-[r:WORKS_IN(title)]->(anon_1) WHERE title IS NOT NULL | 15 | 15 | 16 | 2/0 | 0.527 | In Pipeline 0 | ++-------------------------------------------+----+----------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 86 +---- + +====== [[query-plan-undirected-relationship-index-scan]] == Undirected Relationship Index Scan @@ -220,6 +314,54 @@ Total database accesses: 16, total allocated memory: 184 ====== +[[query-plan-partitioned-undirected-relationship-index-scan]] +== Partitioned Undirected Relationship Index Scan +// PartitionedUndirectedRelationshipIndexScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + + +The `PartitionedUndirectedRelationshipIndexScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-undirected-relationship-index-scan[`UndirectedRelationshipIndexScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + +.PartitionedUndirectedRelationshipIndexScan +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH ()-[r: WORKS_IN]-() +WHERE r.title IS NOT NULL +RETURN r +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++---------------------------------------------+----+---------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++---------------------------------------------+----+---------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | r | 30 | 30 | 140 | 1/0 | 3.088 | In Pipeline 1 | +| | +----+---------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedUndirectedRelationshipIndexScan | 1 | RANGE INDEX (anon_0)-[r:WORKS_IN(title)]-(anon_1) WHERE title IS NOT NULL | 30 | 30 | 16 | 2/0 | 0.572 | In Pipeline 0 | ++---------------------------------------------+----+---------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 156 +---- + +====== + [[query-plan-directed-relationship-index-seek]] == Directed Relationship Index Seek @@ -265,6 +407,54 @@ Total database accesses: 2, total allocated memory: 184 ====== +[[query-plan-partitioned-directed-relationship-index-seek]] +== Partitioned Directed Relationship Index Seek +// PartitionedDirectedRelationshipIndexSeek +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + + +The `PartitionedDirectedRelationshipIndexSeek` is a variant of the the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-directed-relationship-index-seek[`DirectedRelationshipIndexSeek`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + +.PartitionedDirectedRelationshipIndexSeek +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (candidate)-[r:WORKS_IN]->() +WHERE r.title = 'chief architect' +RETURN candidate +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++-------------------------------------------+----+-----------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++-------------------------------------------+----+-----------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | candidate | 2 | 1 | 2 | 2/0 | 0.284 | In Pipeline 1 | +| | +----+-----------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedDirectedRelationshipIndexSeek | 1 | RANGE INDEX (candidate)-[r:WORKS_IN(title)]->(anon_0) WHERE title = $autostring_0 | 2 | 1 | 2 | 2/0 | 0.148 | In Pipeline 0 | ++-------------------------------------------+----+-----------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 4 +---- + +====== + [[query-plan-undirected-relationship-index-seek]] == Undirected Relationship Index Seek @@ -310,6 +500,51 @@ Total database accesses: 2, total allocated memory: 184 ====== +[[query-plan-partitioned-undirected-relationship-index-seek]] +== Partitioned Undirected Relationship Index Seek +// PartitionedUndirectedRelationshipIndexSeek + +The `PartitionedUndirectedRelationshipIndexSeek` operator finds relationships and their start and end nodes using an index seek. +The relationship variable and the index used are shown in the arguments of the operator. + + +.PartitionedUndirectedRelationshipIndexSeek +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (candidate)-[r:WORKS_IN]-() +WHERE r.title = 'chief architect' +RETURN candidate +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++---------------------------------------------+----+----------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++---------------------------------------------+----+----------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | candidate | 4 | 2 | 4 | 2/0 | 0.333 | In Pipeline 1 | +| | +----+----------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedUndirectedRelationshipIndexSeek | 1 | RANGE INDEX (candidate)-[r:WORKS_IN(title)]-(anon_0) WHERE title = $autostring_0 | 4 | 2 | 2 | 2/0 | 0.151 | In Pipeline 0 | ++---------------------------------------------+----+----------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 6 +---- + +====== + [[query-plan-directed-relationship-by-element-id-seek]] == Directed Relationship By Element Id Seek @@ -726,6 +961,56 @@ Total database accesses: 46, total allocated memory: 184 ====== +[[query-plan-partitioned-directed-relationship-index-seek-by-range]] +== Partitioned Directed Relationship Index Seek By Range +// PartitionedDirectedRelationshipIndexSeekByRange +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + + +The `PartitionedDirectedRelationshipIndexSeekByRange` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-directed-relationship-index-seek-by-range[`DirectedRelationshipIndexSeekByRange`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + +.PartitionedDirectedRelationshipIndexSeekByRange +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (candidate: Person)-[r:WORKS_IN]->(location) +WHERE r.duration > 100 +RETURN candidate +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++--------------------------------------------------+----+----------------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++--------------------------------------------------+----+----------------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| +ProduceResults | 0 | candidate | 4 | 15 | 30 | 1/0 | 1.031 | In Pipeline 1 | +| | +----+----------------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| +Filter | 1 | candidate:Person | 4 | 15 | 30 | | | | +| | +----+----------------------------------------------------------------------------------------+----------------+------+---------+ | | | +| +PartitionedDirectedRelationshipIndexSeekByRange | 2 | RANGE INDEX (candidate)-[r:WORKS_IN(duration)]->(location) WHERE duration > $autoint_0 | 4 | 15 | 16 | 3/0 | 0.203 | Fused in Pipeline 0 | ++--------------------------------------------------+----+----------------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ + +Total database accesses: 76 +---- + +====== + [[query-plan-undirected-relationship-index-seek-by-range]] == Undirected Relationship Index Seek By Range @@ -773,6 +1058,56 @@ Total database accesses: 76, total allocated memory: 184 ====== +[[query-plan-partitioned-undirected-relationship-index-seek-by-range]] +== Partitioned Undirected Relationship Index Seek By Range +// PartitionedUndirectedRelationshipIndexSeekByRange +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + + +The `PartitionedUndirectedRelationshipIndexSeekByRange` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-undirected-relationship-index-seek-by-range[`UndirectedRelationshipIndexSeekByRange`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the store to be partitioned into different segments where each segment can be scanned independently in parallel. + +.PartitionedUndirectedRelationshipIndexSeekByRange +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (candidate: Person)-[r:WORKS_IN]-(location) +WHERE r.duration > 100 +RETURN candidate +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++----------------------------------------------------+----+---------------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++----------------------------------------------------+----+---------------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| +ProduceResults | 0 | candidate | 5 | 15 | 30 | 1/0 | 0.918 | In Pipeline 1 | +| | +----+---------------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| +Filter | 1 | candidate:Person | 5 | 15 | 60 | | | | +| | +----+---------------------------------------------------------------------------------------+----------------+------+---------+ | | | +| +PartitionedUndirectedRelationshipIndexSeekByRange | 2 | RANGE INDEX (candidate)-[r:WORKS_IN(duration)]-(location) WHERE duration > $autoint_0 | 8 | 30 | 16 | 3/0 | 0.413 | Fused in Pipeline 0 | ++----------------------------------------------------+----+---------------------------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ + +Total database accesses: 106 +---- + +====== + [[query-plan-union-node-by-labels-scan]] == Union Node By Labels Scan @@ -814,6 +1149,50 @@ Total database accesses: 13, total allocated memory: 184 ====== +[[query-plan-partitioned-union-node-by-labels-scan]] +== Partitioned Union Node By Labels Scan +// PartitionedUnionNodeByLabelsScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedUnionNodeByLabelsScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-union-node-by-labels-scan[`UnionNodeByLabelsScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. +====== + +.Query +[source,cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (countryOrLocation:Country|Location) +RETURN countryOrLocation +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++-----------------------------------+----+------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++-----------------------------------+----+------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | countryOrLocation | 17 | 11 | 22 | 2/0 | 1.548 | In Pipeline 1 | +| | +----+------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedUnionNodeByLabelsScan | 1 | countryOrLocation:Country|Location | 17 | 11 | 13 | 2/0 | 1.976 | In Pipeline 0 | ++-----------------------------------+----+------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 35 +---- + +====== + [[query-plan-intersection-node-by-labels-scan]] == Intersection Node By Labels Scan @@ -857,6 +1236,51 @@ Total database accesses: 13, total allocated memory: 184 ====== +[[query-plan-partitioned-intersection-node-by-labels-scan]] +== Partitioned Intersection Node By Labels Scan +// PartitionedIntersectionNodeByLabelsScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedIntersectionNodeByLabelsScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-intersection-node-by-labels-scan[`IntersectionNodeByLabelsScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. +====== + +.Query +[source,cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (countryAndLocation:Country&Location) +RETURN countryAndLocation +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + + +------------------------------------------+----+-------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++------------------------------------------+----+-------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | countryAndLocation | 3 | 0 | 0 | 0/0 | 0.018 | In Pipeline 1 | +| | +----+-------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedIntersectionNodeByLabelsScan | 1 | countryAndLocation:Country&Location | 3 | 0 | 13 | 2/0 | 0.770 | In Pipeline 0 | ++------------------------------------------+----+-------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 13 +---- + +====== + [[query-plan-directed-all-relationships-scan]] == Directed All Relationships Scan @@ -897,6 +1321,48 @@ Total database accesses: 28, total allocated memory: 184 ---- ====== +[[query-plan-partitioned-directed-all-relationships-scan]] +== Partitioned Directed All Relationships Scan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedDirectedAllRelationshipsScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-directed-all-relationships-scan[`DirectedAllRelationshipsScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the store to be partitioned into different segments where each segment can be scanned independently in parallel. + +====== + +.Query +[source,cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH ()-[r]->() RETURN r +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++------------------------------------------+----+------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | r | 28 | 28 | 83 | 2/0 | 3.872 | In Pipeline 1 | +| | +----+------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedDirectedAllRelationshipsScan | 1 | (anon_0)-[r]->(anon_1) | 28 | 28 | 28 | 3/0 | 1.954 | In Pipeline 0 | ++------------------------------------------+----+------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 111 + +---- +====== + [[query-plan-undirected-all-relationships-scan]] == Undirected All Relationships Scan //UndirectedAllRelationshipsScan @@ -904,10 +1370,140 @@ The `UndirectedAllRelationshipsScan` operator fetches all relationships and thei ====== .Query -[source,cypher] +[source,cypher] +---- +PROFILE +MATCH ()-[r]-() RETURN r +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PIPELINED + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++---------------------------------+-----------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ +| Operator | Details | Estimated Rows | Rows | DB Hits | Memory (Bytes) | Page Cache Hits/Misses | Time (ms) | Pipeline | ++---------------------------------+-----------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ +| +ProduceResults | r | 56 | 56 | 0 | | | | | +| | +-----------------------+----------------+------+---------+----------------+ | | | +| +UndirectedAllRelationshipsScan | (anon_0)-[r]-(anon_1) | 56 | 56 | 28 | 120 | 3/0 | 1.110 | Fused in Pipeline 0 | ++---------------------------------+-----------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ + +Total database accesses: 28, total allocated memory: 184 + +---- +====== + +[[query-plan-partitioned-undirected-all-relationships-scan]] +== Partitioned Undirected All Relationships Scan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedUndirectedAllRelationshipsScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-undirected-all-relationships-scan[`UndirectedAllRelationshipsScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the store to be partitioned into different segments where each segment can be scanned independently in parallel. + +====== +.Query +[source,cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH ()-[r]-() RETURN r +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++--------------------------------------------+----+-----------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++--------------------------------------------+----+-----------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | r | 56 | 56 | 166 | 2/0 | 4.905 | In Pipeline 1 | +| | +----+-----------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedUndirectedAllRelationshipsScan | 1 | (anon_0)-[r]-(anon_1) | 56 | 56 | 28 | 9/0 | 1.573 | In Pipeline 0 | ++--------------------------------------------+----+-----------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 194 + +---- +====== + +[[query-plan-directed-relationship-type-scan]] +== Directed Relationship Type Scan +// DirectedRelationshipTypeScan + +The `DirectedRelationshipTypeScan` operator fetches all relationships and their start and end nodes with a specific type from the relationship type index. + + +.DirectedRelationshipTypeScan +====== + +.Query +[source, cypher] +---- +PROFILE +MATCH ()-[r: FRIENDS_WITH]->() +RETURN r +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PIPELINED + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++-------------------------------+-------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ +| Operator | Details | Estimated Rows | Rows | DB Hits | Memory (Bytes) | Page Cache Hits/Misses | Time (ms) | Pipeline | ++-------------------------------+-------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ +| +ProduceResults | r | 12 | 12 | 0 | | | | | +| | +-------------------------------------+----------------+------+---------+----------------+ | | | +| +DirectedRelationshipTypeScan | (anon_0)-[r:FRIENDS_WITH]->(anon_1) | 12 | 12 | 13 | 120 | 2/1 | 0.557 | Fused in Pipeline 0 | ++-------------------------------+-------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ + +Total database accesses: 13, total allocated memory: 184 +---- + +====== + +[[query-plan-partitioned-directed-relationship-types-scan]] +== Partitioned Directed Relationship Type Scan +// PartitionedDirectedRelationshipTypeScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedDirectedRelationshipTypeScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-directed-relationship-type-scan[`DirectedRelationshipTypeScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + +.PartitionedDirectedRelationshipTypeScan +====== + +.Query +[source, cypher] ---- +CYPHER runtime=parallel PROFILE -MATCH ()-[r]-() RETURN r +MATCH ()-[r: FRIENDS_WITH]->() +RETURN r ---- .Query Plan @@ -915,40 +1511,39 @@ MATCH ()-[r]-() RETURN r ---- Planner COST -Runtime PIPELINED +Runtime PARALLEL Runtime version {neo4j-version-minor} Batch size 128 -+---------------------------------+-----------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ -| Operator | Details | Estimated Rows | Rows | DB Hits | Memory (Bytes) | Page Cache Hits/Misses | Time (ms) | Pipeline | -+---------------------------------+-----------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ -| +ProduceResults | r | 56 | 56 | 0 | | | | | -| | +-----------------------+----------------+------+---------+----------------+ | | | -| +UndirectedAllRelationshipsScan | (anon_0)-[r]-(anon_1) | 56 | 56 | 28 | 120 | 3/0 | 1.110 | Fused in Pipeline 0 | -+---------------------------------+-----------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ - -Total database accesses: 28, total allocated memory: 184 +++------------------------------------------+----+-------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + | Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | + +------------------------------------------+----+-------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + | +ProduceResults | 0 | r | 12 | 12 | 12 | 0/0 | 0.560 | In Pipeline 1 | + | | +----+-------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + | +PartitionedDirectedRelationshipTypeScan | 1 | (anon_0)-[r:FRIENDS_WITH]->(anon_1) | 12 | 12 | 13 | 2/0 | 0.167 | In Pipeline 0 | + +------------------------------------------+----+-------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + Total database accesses: 25 ---- + ====== -[[query-plan-directed-relationship-type-scan]] -== Directed Relationship Type Scan -// DirectedRelationshipTypeScan -The `DirectedRelationshipTypeScan` operator fetches all relationships and their start and end nodes with a specific type from the relationship type index. +[[query-plan-undirected-relationship-type-scan]] +== Undirected Relationship Type Scan +// UndirectedRelationshipTypeScan +The `UndirectedRelationshipTypeScan` operator fetches all relationships and their start and end nodes with a specific type from the relationship type index. -.DirectedRelationshipTypeScan ====== .Query [source, cypher] ---- PROFILE -MATCH ()-[r: FRIENDS_WITH]->() +MATCH ()-[r: FRIENDS_WITH]-() RETURN r ---- @@ -963,31 +1558,35 @@ Runtime version {neo4j-version-minor} Batch size 128 -+-------------------------------+-------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ -| Operator | Details | Estimated Rows | Rows | DB Hits | Memory (Bytes) | Page Cache Hits/Misses | Time (ms) | Pipeline | -+-------------------------------+-------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ -| +ProduceResults | r | 12 | 12 | 0 | | | | | -| | +-------------------------------------+----------------+------+---------+----------------+ | | | -| +DirectedRelationshipTypeScan | (anon_0)-[r:FRIENDS_WITH]->(anon_1) | 12 | 12 | 13 | 120 | 2/1 | 0.557 | Fused in Pipeline 0 | -+-------------------------------+-------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ ++---------------------------------+------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ +| Operator | Details | Estimated Rows | Rows | DB Hits | Memory (Bytes) | Page Cache Hits/Misses | Time (ms) | Pipeline | ++---------------------------------+------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ +| +ProduceResults | r | 24 | 24 | 0 | | | | | +| | +------------------------------------+----------------+------+---------+----------------+ | | | +| +UndirectedRelationshipTypeScan | (anon_0)-[r:FRIENDS_WITH]-(anon_1) | 24 | 24 | 13 | 120 | 2/1 | 0.749 | Fused in Pipeline 0 | ++---------------------------------+------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ Total database accesses: 13, total allocated memory: 184 ---- ====== +[[query-plan-partitioned-undirected-relationship-type-scan]] +== Partitioned Undirected Relationship Type Scan +// PartitionedUndirectedRelationshipTypeScan +// New in 5.17 -[[query-plan-undirected-relationship-type-scan]] -== Undirected Relationship Type Scan -// UndirectedRelationshipTypeScan +_This feature was introduced in Neo4j 5.17._ -The `UndirectedRelationshipTypeScan` operator fetches all relationships and their start and end nodes with a specific type from the relationship type index. +The `PartitionedUndirectedRelationshipTypeScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-undirected-relationship-type-scan[`UndirectedRelationshipTypeScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. ====== .Query [source, cypher] ---- +CYPHER runtime=parallel PROFILE MATCH ()-[r: FRIENDS_WITH]-() RETURN r @@ -998,21 +1597,21 @@ RETURN r ---- Planner COST -Runtime PIPELINED +Runtime PARALLEL Runtime version {neo4j-version-minor} Batch size 128 -+---------------------------------+------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ -| Operator | Details | Estimated Rows | Rows | DB Hits | Memory (Bytes) | Page Cache Hits/Misses | Time (ms) | Pipeline | -+---------------------------------+------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ -| +ProduceResults | r | 24 | 24 | 0 | | | | | -| | +------------------------------------+----------------+------+---------+----------------+ | | | -| +UndirectedRelationshipTypeScan | (anon_0)-[r:FRIENDS_WITH]-(anon_1) | 24 | 24 | 13 | 120 | 2/1 | 0.749 | Fused in Pipeline 0 | -+---------------------------------+------------------------------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+ ++--------------------------------------------+----+------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++--------------------------------------------+----+------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | r | 24 | 24 | 24 | 1/0 | 1.466 | In Pipeline 1 | +| | +----+------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedUndirectedRelationshipTypeScan | 1 | (anon_0)-[r:FRIENDS_WITH]-(anon_1) | 24 | 24 | 13 | 2/0 | 0.171 | In Pipeline 0 | ++--------------------------------------------+----+------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ -Total database accesses: 13, total allocated memory: 184 +Total database accesses: 37 ---- ====== @@ -1022,10 +1621,10 @@ Total database accesses: 13, total allocated memory: 184 == Directed Union Relationship Types Scan // DirectedUnionRelationshipTypesScan -The `DirectedUnionRelationshipTypeScan` operator fetches all relationships and their start and end nodes with at least one of the provided types from the relationship type index. +The `DirectedUnionRelationshipTypesScan` operator fetches all relationships and their start and end nodes with at least one of the provided types from the relationship type index. -.DirectedUnionRelationshipTypeScan +.DirectedUnionRelationshipTypesScan ====== .Query @@ -1060,12 +1659,59 @@ Total database accesses: 14, total allocated memory: 184 ====== +[[query-plan-partitioned-directed-union-relationship-types-scan]] +== Partitioned Directed Union Relationship Types Scan +// PartitionedDirectedUnionRelationshipTypesScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedDirectedUnionRelationshipTypeScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-directed-union-relationship-types-scan[`DirectedUnionRelationshipTypesScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + + +.PartitionedDirectedUnionRelationshipTypesScan +====== + +.Query +[source,cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH ()-[friendOrFoe: FRIENDS_WITH|FOE]->() +RETURN friendOrFoe +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++------------------------------------------------+----+---------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++------------------------------------------------+----+---------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | friendOrFoe | 15 | 12 | 12 | 0/0 | 0.570 | In Pipeline 1 | +| | +----+---------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedDirectedUnionRelationshipTypesScan | 1 | (anon_0)-[friendOrFoe:FRIENDS_WITH|FOE]->(anon_1) | 15 | 12 | 13 | 2/0 | 0.170 | In Pipeline 0 | ++------------------------------------------------+----+---------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 25 +---- + +====== + [[query-plan-undirected-union-relationship-types-scan]] == Undirected Union Relationship Types Scan // UndirectedUnionRelationshipTypesScan -The `UndirectedUnionRelationshipTypeScan` operator fetches all relationships and their start and end nodes with at least one of the provided types from the relationship type index. +The `UndirectedUnionRelationshipTypesScan` operator fetches all relationships and their start and end nodes with at least one of the provided types from the relationship type index. .UndirectedUnionRelationshipTypeScan @@ -1103,6 +1749,52 @@ Total database accesses: 14, total allocated memory: 184 ====== +[[query-plan-partitioned-undirected-union-relationship-types-scan]] +== Partitioned Undirected Union Relationship Types Scan +// PartitionedUndirectedUnionRelationshipTypesScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedUndirectedUnionRelationshipTypeScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-undirected-union-relationship-types-scan[`UndirectedUnionRelationshipTypesScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + +.PartitionedUndirectedUnionRelationshipTypesScan +====== + +.Query +[source,cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH ()-[friendOrFoe: FRIENDS_WITH|FOE]-() +RETURN friendOrFoe +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++--------------------------------------------------+----+--------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++--------------------------------------------------+----+--------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | friendOrFoe | 30 | 24 | 24 | 0/0 | 0.896 | In Pipeline 1 | +| | +----+--------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedUndirectedUnionRelationshipTypesScan | 1 | (anon_0)-[friendOrFoe:FRIENDS_WITH|FOE]-(anon_1) | 30 | 24 | 13 | 2/0 | 0.818 | In Pipeline 0 | ++--------------------------------------------------+----+--------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 37 +---- + +====== + [[query-plan-node-by-elementid-seek]] == Node By ElementId Seek // NodeByElementIdSeek @@ -1235,6 +1927,53 @@ Total database accesses: 15, total allocated memory: 184 ====== +[[query-plan-partitioned-node-by-label-scan]] +== Partitioned Node By Label Scan +// PartitionedNodeByLabelScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedNodeByLabelScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-node-by-label-scan[`NodeByLabelScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + + +.PartitionedNodeByLabelScan +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (person:Person) +RETURN person +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++-----------------------------+----+---------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++-----------------------------+----+---------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | person | 14 | 14 | 28 | 2/0 | 0.623 | In Pipeline 1 | +| | +----+---------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedNodeByLabelScan | 1 | person:Person | 14 | 14 | 15 | 1/0 | 0.094 | In Pipeline 0 | ++-----------------------------+----+---------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 43 +---- + +====== + [[query-plan-node-index-seek]] == Node Index Seek @@ -1287,6 +2026,53 @@ Total database accesses: 2, total allocated memory: 184 ====== +[[query-plan-partitioned-node-index-seek]] +== Partitioned Node Index Seek +// PartitionedNodeIndexSeek +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedNodeIndexSeek` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-node-index-seek[`NodeIndexSeek`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + + +.PartitionedNodeIndexSeek +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (location:Location {name: 'Malmo'}) +RETURN location +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++---------------------------+----+----------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++---------------------------+----+----------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | location | 0 | 1 | 2 | 2/0 | 0.179 | In Pipeline 1 | +| | +----+----------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedNodeIndexSeek | 1 | RANGE INDEX location:Location(name) WHERE name = $autostring_0 | 0 | 1 | 2 | 1/0 | 0.167 | In Pipeline 0 | ++---------------------------+----+----------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 4 +---- + +====== + [[query-plan-node-unique-index-seek]] == Node Unique Index Seek @@ -1502,6 +2288,54 @@ Total database accesses: 2, total allocated memory: 184 ====== +[[query-plan-partitioned-node-index-seek-by-range]] +== Partitioned Node Index Seek By Range +// PartitionedNodeIndexSeekByRange +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedNodeIndexSeekByRange` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-node-index-seek-by-range[`NodeIndexSeekByRange`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + + +.PartitionedNodeIndexSeekByRange +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (l:Location) +WHERE l.name STARTS WITH 'Lon' +RETURN l +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++----------------------------------+----+-------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++----------------------------------+----+-------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | l | 0 | 1 | 2 | 2/0 | 0.191 | In Pipeline 1 | +| | +----+-------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedNodeIndexSeekByRange | 1 | RANGE INDEX l:Location(name) WHERE name STARTS WITH $autostring_0 | 0 | 1 | 2 | 1/0 | 0.087 | In Pipeline 0 | ++----------------------------------+----+-------------------------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 4 +---- + +====== + [[query-plan-node-unique-index-seek-by-range]] == Node Unique Index Seek By Range @@ -1689,6 +2523,53 @@ Total database accesses: 11, total allocated memory: 184 ====== +[[query-plan-partitioned-node-index-scan]] +== Partitioned Node Index Scan +// PartitionedNodeIndexScan +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedNodeIndexScan` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-node-index-scan[`NodeIndexScan`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + + +.PartitionedNodeIndexScan +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +MATCH (l:Location) +WHERE l.name IS NOT NULL +RETURN l +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++---------------------------+----+-----------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++---------------------------+----+-----------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +ProduceResults | 0 | l | 1 | 10 | 20 | 2/0 | 0.472 | In Pipeline 1 | +| | +----+-----------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ +| +PartitionedNodeIndexScan | 1 | RANGE INDEX l:Location(name) WHERE name IS NOT NULL | 1 | 10 | 11 | 1/0 | 0.187 | In Pipeline 0 | ++---------------------------+----+-----------------------------------------------------+----------------+------+---------+------------------------+-----------+---------------+ + +Total database accesses: 31 +---- + +====== // --- apply operators --- @@ -4742,6 +5623,52 @@ Total database accesses: 0, total allocated memory: 184 ====== +[[query-plan-partitioned-unwind]] +== Partitioned Unwind +// PartitionedUnwind +// New in 5.17 + +_This feature was introduced in Neo4j 5.17._ + +The `PartitionedUnwind` is a variant of the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-unwind[`Unwind`] operator used by the xref:planning-and-tuning/runtimes/concepts.adoc#runtimes-parallel-runtime[parallel runtime]. +It allows the index to be partitioned into different segments where each segment can be scanned independently in parallel. + + +.PartitionedUnwind +====== + +.Query +[source, cypher] +---- +CYPHER runtime=parallel +PROFILE +UNWIND range(1, 5) AS value +RETURN value +---- + +.Query Plan +[role="queryplan", subs="attributes+"] +---- +Planner COST + +Runtime PARALLEL + +Runtime version {neo4j-version-minor} + +Batch size 128 + ++--------------------+----+----------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| Operator | Id | Details | Estimated Rows | Rows | DB Hits | Page Cache Hits/Misses | Time (ms) | Pipeline | ++--------------------+----+----------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| +ProduceResults | 0 | value | 10 | 5 | 0 | 0/0 | 0.119 | In Pipeline 1 | +| | +----+----------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ +| +PartitionedUnwind | 1 | range($autoint_0, $autoint_1) AS value | 10 | 5 | 0 | | | Fused in Pipeline 0 | ++--------------------+----+----------------------------------------+----------------+------+---------+------------------------+-----------+---------------------+ + +Total database accesses: 0 +---- + +====== [[query-plan-exhaustive-limit]] == Exhaustive Limit diff --git a/modules/ROOT/pages/planning-and-tuning/runtimes/concepts.adoc b/modules/ROOT/pages/planning-and-tuning/runtimes/concepts.adoc index 813ecaf95..c40aa1dc5 100644 --- a/modules/ROOT/pages/planning-and-tuning/runtimes/concepts.adoc +++ b/modules/ROOT/pages/planning-and-tuning/runtimes/concepts.adoc @@ -273,44 +273,47 @@ Runtime version {neo4j-version-minor} Batch size 128 -+-------------------+----+------------------------------------------------------------------------+----------------+---------------------+ -| Operator | Id | Details | Estimated Rows | Pipeline | -+-------------------+----+------------------------------------------------------------------------+----------------+---------------------+ -| +ProduceResults | 0 | `count(*)` | 1 | In Pipeline 6 | -| | +----+------------------------------------------------------------------------+----------------+---------------------+ -| +EagerAggregation | 1 | count(*) AS `count(*)` | 1 | | -| | +----+------------------------------------------------------------------------+----------------+ | -| +Filter | 2 | not anon_1 = anon_5 AND anon_0.name = $autostring_0 AND anon_0:Station | 0 | | -| | +----+------------------------------------------------------------------------+----------------+ | -| +Expand(All) | 3 | (d)-[anon_1:CALLS_AT]->(anon_0) | 0 | Fused in Pipeline 5 | -| | +----+------------------------------------------------------------------------+----------------+---------------------+ -| +Filter | 4 | d:Stop | 0 | | -| | +----+------------------------------------------------------------------------+----------------+ | -| +NullifyMetadata | 14 | | 0 | | -| | +----+------------------------------------------------------------------------+----------------+ | -| +Repeat(Trail) | 5 | (a) (...){1, *} (d) | 0 | Fused in Pipeline 4 | -| |\ +----+------------------------------------------------------------------------+----------------+---------------------+ -| | +Filter | 6 | isRepeatTrailUnique(anon_7) AND anon_2:Stop | 6 | | -| | | +----+------------------------------------------------------------------------+----------------+ | -| | +Expand(All) | 7 | (anon_4)<-[anon_7:NEXT]-(anon_2) | 6 | Fused in Pipeline 3 | -| | | +----+------------------------------------------------------------------------+----------------+---------------------+ -| | +Filter | 8 | anon_4:Stop | 11 | | -| | | +----+------------------------------------------------------------------------+----------------+ | -| | +Argument | 9 | anon_4 | 13 | Fused in Pipeline 2 | -| | +----+------------------------------------------------------------------------+----------------+---------------------+ -| +Filter | 10 | a:Stop | 0 | | -| | +----+------------------------------------------------------------------------+----------------+ | -| +Expand(All) | 11 | (anon_6)<-[anon_5:CALLS_AT]-(a) | 0 | Fused in Pipeline 1 | -| | +----+------------------------------------------------------------------------+----------------+---------------------+ -| +Filter | 12 | anon_6.name = $autostring_1 | 1 | | -| | +----+------------------------------------------------------------------------+----------------+ | -| +NodeByLabelScan | 13 | anon_6:Station | 10 | Fused in Pipeline 0 | -+-------------------+----+------------------------------------------------------------------------+----------------+---------------------+ ++-----------------------------+----+------------------------------------------------------------------------+----------------+---------------------+ +| Operator | Id | Details | Estimated Rows | Pipeline | ++-----------------------------+----+------------------------------------------------------------------------+----------------+---------------------+ +| +ProduceResults | 0 | `count(*)` | 1 | In Pipeline 6 | +| | +----+------------------------------------------------------------------------+----------------+---------------------+ +| +EagerAggregation | 1 | count(*) AS `count(*)` | 1 | | +| | +----+------------------------------------------------------------------------+----------------+ | +| +Filter | 2 | NOT anon_1 = anon_5 AND anon_0.name = $autostring_0 AND anon_0:Station | 0 | | +| | +----+------------------------------------------------------------------------+----------------+ | +| +Expand(All) | 3 | (d)-[anon_1:CALLS_AT]->(anon_0) | 0 | Fused in Pipeline 5 | +| | +----+------------------------------------------------------------------------+----------------+---------------------+ +| +Filter | 4 | d:Stop | 0 | | +| | +----+------------------------------------------------------------------------+----------------+ | +| +NullifyMetadata | 14 | | 0 | | +| | +----+------------------------------------------------------------------------+----------------+ | +| +Repeat(Trail) | 5 | (a) (...){1, *} (d) | 0 | Fused in Pipeline 4 | +| |\ +----+------------------------------------------------------------------------+----------------+---------------------+ +| | +Filter | 6 | isRepeatTrailUnique(anon_8) AND anon_7:Stop | 6 | | +| | | +----+------------------------------------------------------------------------+----------------+ | +| | +Expand(All) | 7 | (anon_9)<-[anon_8:NEXT]-(anon_7) | 6 | Fused in Pipeline 3 | +| | | +----+------------------------------------------------------------------------+----------------+---------------------+ +| | +Filter | 8 | anon_9:Stop | 11 | | +| | | +----+------------------------------------------------------------------------+----------------+ | +| | +Argument | 9 | anon_9 | 13 | Fused in Pipeline 2 | +| | +----+------------------------------------------------------------------------+----------------+---------------------+ +| +Filter | 10 | a:Stop | 0 | | +| | +----+------------------------------------------------------------------------+----------------+ | +| +Expand(All) | 11 | (anon_6)<-[anon_5:CALLS_AT]-(a) | 0 | Fused in Pipeline 1 | +| | +----+------------------------------------------------------------------------+----------------+---------------------+ +| +Filter | 12 | anon_6.name = $autostring_1 | 1 | | +| | +----+------------------------------------------------------------------------+----------------+ | +| +PartitionedNodeByLabelScan | 13 | anon_6:Station | 10 | Fused in Pipeline 0 | ++-----------------------------+----+------------------------------------------------------------------------+----------------+---------------------+ ---- A key difference between the physical plans produced by the parallel runtime compared to those generated by pipelined runtime is that, in general, more pipelines are produced when using the parallel runtime (in this case, seven instead of the four produced by the same query being run on pipelined runtime). This is because, when executing a query in the parallel runtime, it is more efficient to have more tasks that can be run in parallel, whereas when running a single-threaded execution in the pipelined runtime it is more efficient to fuse several pipelines together. +Another important difference is that the parallel runtime uses partitioned operators (xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-partitioned-node-by-label-scan[`PartitionedNodeByLabelScan`] in this case). +These operators first segment the retrieved data and then operate on each segment in parallel. + The parallel runtime shares the same architecture as the pipelined runtime, meaning that it will transform the logical plan into the same type of execution graph as described above. However, when using parallel runtime, each pipeline task can be executed in a separate thread. Another similarity with pipelined runtime is that queries run on the parallel runtime will begin by generating the first pipeline which eventually will produce a morsel in the input buffer of the subsequent pipeline. @@ -331,10 +334,10 @@ Consider the execution graph below, based on the same example query: image::runtimes_execution_graph2.svg[width="900",role="middle"] -The execution graph shows that execution starts at `pipeline 0`, which consists of the operator `NodeByLabelScan` and can be executed simultaneously on all available threads working on different morsels of data. +The execution graph shows that execution starts at `pipeline 0`, which consists of the operator `PartitionedNodeByLabelScan` and can be executed simultaneously on all available threads working on different morsels of data. Once pipeline `0` has produced at least one full morsel of data, any thread can then start executing `pipeline 1`, while other threads may continue to execute `pipeline 0`. More specifically, once there is data from a pipeline, the scheduler can proceed to the next pipeline while concurrently executing earlier pipelines. -In this case, `pipeline 5` ends with an aggregation (performed by the EagerAggregation operator), which means that the last pipeline (6) cannot start until all preceding pipelines are completely finished for all the preceding morsels of data. +In this case, `pipeline 5` ends with an aggregation (performed by the xref:planning-and-tuning/operators/operators-detail.adoc#query-plan-eager-aggregation[`EagerAggregation`] operator), which means that the last pipeline (`6`) cannot start until all preceding pipelines are completely finished for all the preceding morsels of data. [[runtimes-parallel-runtime-considerations]] === Considerations diff --git a/package-lock.json b/package-lock.json index 88f1c92b8..7f25845cb 100644 --- a/package-lock.json +++ b/package-lock.json @@ -22,7 +22,7 @@ }, "devDependencies": { "express": "^4.17.1", - "nodemon": "^3.0.2" + "nodemon": "^3.0.3" } }, "node_modules/@antora/asciidoc-loader": { @@ -1838,9 +1838,9 @@ "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==" }, "node_modules/nodemon": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.0.2.tgz", - "integrity": "sha512-9qIN2LNTrEzpOPBaWHTm4Asy1LxXLSickZStAQ4IZe7zsoIpD/A7LWxhZV3t4Zu352uBcqVnRsDXSMR2Sc3lTA==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.0.3.tgz", + "integrity": "sha512-7jH/NXbFPxVaMwmBCC2B9F/V6X1VkEdNgx3iu9jji8WxWcvhMWkmhNWhI5077zknOnZnBzba9hZP6bCPJLSReQ==", "dev": true, "dependencies": { "chokidar": "^3.5.2", @@ -4444,9 +4444,9 @@ "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==" }, "nodemon": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.0.2.tgz", - "integrity": "sha512-9qIN2LNTrEzpOPBaWHTm4Asy1LxXLSickZStAQ4IZe7zsoIpD/A7LWxhZV3t4Zu352uBcqVnRsDXSMR2Sc3lTA==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.0.3.tgz", + "integrity": "sha512-7jH/NXbFPxVaMwmBCC2B9F/V6X1VkEdNgx3iu9jji8WxWcvhMWkmhNWhI5077zknOnZnBzba9hZP6bCPJLSReQ==", "dev": true, "requires": { "chokidar": "^3.5.2", diff --git a/package.json b/package.json index e15cf3ae6..0633e84c2 100644 --- a/package.json +++ b/package.json @@ -32,7 +32,7 @@ }, "devDependencies": { "express": "^4.17.1", - "nodemon": "^3.0.2" + "nodemon": "^3.0.3" }, "overrides": { "@antora/site-generator-default": {