================================================================================
SHARED FAILURES (Both PropertyGraph and NetworKitRust)
================================================================================

ExistentialSubquery2 - Full existential subquery::Full existential subquery with aggregation
List11 - Create a list from a range::Create an empty list if range direction and step direction are inconsistent
Literals6 - String::Return a single-quoted string with escaped characters
Match4 - Match variable length patterns scenarios::Matching relationships into a list and matching variable length using the list
Match4 - Match variable length patterns scenarios::Matching variable length patterns including a bound relationship
Match5 - Match variable length patterns over given graphs scenarios::Handling mixed relationship patterns and directions 2
Match6 - Match named paths scenarios::Named path with undirected fixed variable length pattern
Merge5 - Merge relationships::Use outgoing direction when unspecified
Quantifier1 - None quantifier::None quantifier on list containing nodes
Quantifier2 - Single quantifier::Single quantifier on list containing nodes
Quantifier3 - Any quantifier::Any quantifier on list containing nodes
Quantifier4 - All quantifier::All quantifier on list containing nodes
Return4 - Column renaming::Keeping used expression 1
Return4 - Column renaming::Keeping used expression 3
Return4 - Column renaming::Keeping used expression 4
Temporal10 - Compute Durations Between two Temporal Values::Should handle durations at daylight saving time day
Temporal2 - Create Temporal Values from a String::Should parse duration from string
Temporal6 - Render Temporal Values as a String::Should serialize duration
Temporal8 - Compute Arithmetic Operations on Temporal Values::Should add or subtract duration to or from date
Temporal8 - Compute Arithmetic Operations on Temporal Values::Should multiply or divide durations by numbers
Temporal9 - Truncate Temporal Values::Should truncate datetime
WithOrderBy2 - Order by a single expression::Sort by an expression that is only partially orderable on a non-distinct binding table, but used as a grouping key
WithOrderBy4 - Order by in combination with projection and aliasing::Sort by an aggregate projection

================================================================================
NETWORKIT-ONLY FAILURES
================================================================================

Aggregation1 - Count::[2] Counting loop relationships
Comparison1 - Equality::[5] Comparing relationships to relationships
Comparison1 - Equality::[14] Direction of traversed relationship is not significant for path equality, simple
Comparison2 - Half-bounded Range::[3] Comparing across types yields null, except numbers
Comparison2 - Half-bounded Range::[2] Comparing strings and integers using > in a OR'd predicate
Comparison2 - Half-bounded Range::[1] Comparing strings and integers using > in an AND'd predicate
Comparison4 - Combination of Comparisons::[1] Handling long chains of operators
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[9] Counting directed self-relationships
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[7] Counting distinct undirected self-relationships in self-relationship graph
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[6] Counting undirected self-relationships in self-relationship graph
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[8] Directed match of a simple relationship, count
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[5] Directed match of self-relationship on self-relationship graph, count
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[4] Directed match on self-relationship graph, count
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[10] Mixing directed and undirected pattern parts with self-relationship, count
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[11] Mixing directed and undirected pattern parts with self-relationship, undirected count
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[1] Undirected match in self-relationship graph, count
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[2] Undirected match of self-relationship in self-relationship graph, count
CountingSubgraphMatches1 - Matching subgraph patterns and count the number of matches::[3] Undirected match on simple relationship graph, count
Create2 - Creating relationships::[12] Create a single relationship and a starting node on an existing end node
Create2 - Creating relationships::[11] Create a single relationship and an end node on an existing starting node
Create2 - Creating relationships::[6] Create a single relationship between two existing nodes in the reverse direction
Create2 - Creating relationships::[4] Create two nodes and a single relationship in the reverse direction
Create5 - Multiple hops create patterns::[1] Create a pattern with multiple hops
Create5 - Multiple hops create patterns::[5] Create a pattern with multiple hops and varying directions
Create5 - Multiple hops create patterns::[2] Create a pattern with multiple hops in the reverse direction
Create5 - Multiple hops create patterns::[3] Create a pattern with multiple hops in varying directions
Create5 - Multiple hops create patterns::[4] Create a pattern with multiple hops with multiple types and varying directions
Delete1 - Deleting nodes::[3] Detach deleting connected nodes and relationships
Delete4 - Delete clause interoperation with other clauses::[1] Undirected expand followed by delete and count
Delete4 - Delete clause interoperation with other clauses::[2] Undirected variable length expand followed by delete and count
Delete5 - Delete clause interoperation with built-in data types::[5] Detach delete nodes from nested map/list
Delete6 - Persistence of delete clause side effects::[13] Aggregating in `RETURN` after deleting relationships affects the result set but not the side effects
Delete6 - Persistence of delete clause side effects::[14] Aggregating in `WITH` after deleting relationships affects the result set but not the side effects
Delete6 - Persistence of delete clause side effects::[12] Filtering after deleting relationships affects the result set but not the side effects
Delete6 - Persistence of delete clause side effects::[10] Skipping and limiting to a few results after deleting relationships affects the result set but not the side effects
Delete6 - Persistence of delete clause side effects::[11] Skipping zero result and limiting to all results after deleting relationships does not affect the result set nor the side effects
ExistentialSubquery1 - Simple existential subquery::[2] Simple subquery with WHERE clause
ExistentialSubquery1 - Simple existential subquery::[1] Simple subquery without WHERE clause
ExistentialSubquery2 - Full existential subquery::[1] Full existential subquery
ExistentialSubquery3 - Nested existential subquery::[2] Nested full existential subquery
ExistentialSubquery3 - Nested existential subquery::[3] Nested full existential subquery with pattern predicate
ExistentialSubquery3 - Nested existential subquery::[1] Nested simple existential subquery
Graph4 - Edge relationship type::[1] `type()`
Graph4 - Edge relationship type::[5] `type()` handling Any type
Graph4 - Edge relationship type::[4] `type()` on mixed null and non-null relationships
Graph4 - Edge relationship type::[2] `type()` on two relationships
Graph5 - Node and edge label expressions::[2] Single-labels expression on relationships
Graph6 - Static property access::[5] Statically access a property of a non-null relationship
Graph6 - Static property access::[6] Statically access a property of a optional non-null relationship
Graph6 - Static property access::[8] Statically access a property of a relationship resulting from an expression
Graph8 - Property keys function::[5] Using `keys()` on a relationship, non-empty result
Graph9 - Retrieve all properties as a property map::[2] `properties()` on a relationship
List12 - List Comprehension::[4] Returning a list comprehension
List12 - List Comprehension::[6] Using a list comprehension in a WHERE
List12 - List Comprehension::[5] Using a list comprehension in a WITH
List6 - List size::[8] Get node degree via size of pattern comprehension
List6 - List size::[9] Get node degree via size of pattern comprehension that specifies a relationship type
List6 - List size::[10] Get node degree via size of pattern comprehension that specifies multiple relationship types
List6 - List size::[7] Using size of pattern comprehension to test existence
Match2 - Match relationships::[5] Match relationship with inline property value
Match2 - Match relationships::[6] Match relationships with multiple types
Match2 - Match relationships::[2] Matching a relationship pattern using a label predicate on both sides
Match2 - Match relationships::[4] Matching a self-loop with a directed relationship pattern
Match2 - Match relationships::[3] Matching a self-loop with an undirected relationship pattern
Match3 - Match fixed length patterns::[2] Directed match of a simple relationship
Match3 - Match fixed length patterns::[14] Directed match of self-relationship on self-relationship graph
Match3 - Match fixed length patterns::[13] Directed match on self-relationship graph
Match3 - Match fixed length patterns::[1] Get neighbours
Match3 - Match fixed length patterns::[9] Get related to related to
Match3 - Match fixed length patterns::[4] Get two related nodes
Match3 - Match fixed length patterns::[17] Handling cyclic patterns
Match3 - Match fixed length patterns::[18] Handling cyclic patterns when separated into two parts
Match3 - Match fixed length patterns::[6] Matching a relationship pattern using a label predicate
Match3 - Match fixed length patterns::[23] Matching disconnected patterns
Match3 - Match fixed length patterns::[7] Matching nodes with many labels
Match3 - Match fixed length patterns::[26] Matching twice with a duplicate predicate
Match3 - Match fixed length patterns::[24] Matching twice with duplicate relationship types on same relationship
Match3 - Match fixed length patterns::[8] Matching using relationship predicate with multiples of the same type
Match3 - Match fixed length patterns::[15] Mixing directed and undirected pattern parts with self-relationship, simple
Match3 - Match fixed length patterns::[16] Mixing directed and undirected pattern parts with self-relationship, undirected
Match3 - Match fixed length patterns::[5] Return two subgraphs with bound undirected relationship
Match3 - Match fixed length patterns::[22] Returning bound nodes that are not part of the pattern
Match3 - Match fixed length patterns::[20] Three bound nodes pointing to the same node
Match3 - Match fixed length patterns::[21] Three bound nodes pointing to the same node with extra connections
Match3 - Match fixed length patterns::[19] Two bound nodes pointing to the same node
Match3 - Match fixed length patterns::[11] Undirected match in self-relationship graph
Match3 - Match fixed length patterns::[12] Undirected match of self-relationship in self-relationship graph
Match3 - Match fixed length patterns::[3] Undirected match on simple relationship graph
Match4 - Match variable length patterns scenarios::[1] Handling fixed-length variable length pattern
Match4 - Match variable length patterns scenarios::[4] Matching longer variable length paths
Match4 - Match variable length patterns scenarios::[5] Matching variable length pattern with property predicate
Match4 - Match variable length patterns scenarios::[2] Simple variable length pattern
Match4 - Match variable length patterns scenarios::[3] Zero-length variable length pattern in the middle of the pattern
Match5 - Match variable length patterns over given graphs scenarios::[23] Handling a variable length relationship and a standard relationship in chain, longer 1
Match5 - Match variable length patterns over given graphs scenarios::[24] Handling a variable length relationship and a standard relationship in chain, longer 2
Match5 - Match variable length patterns over given graphs scenarios::[25] Handling a variable length relationship and a standard relationship in chain, longer 3
Match5 - Match variable length patterns over given graphs scenarios::[21] Handling a variable length relationship and a standard relationship in chain, single length 1
Match5 - Match variable length patterns over given graphs scenarios::[22] Handling a variable length relationship and a standard relationship in chain, single length 2
Match5 - Match variable length patterns over given graphs scenarios::[19] Handling a variable length relationship and a standard relationship in chain, zero length 1
Match5 - Match variable length patterns over given graphs scenarios::[20] Handling a variable length relationship and a standard relationship in chain, zero length 2
Match5 - Match variable length patterns over given graphs scenarios::[2] Handling explicitly unbounded variable length match
Match5 - Match variable length patterns over given graphs scenarios::[16] Handling lower bounded variable length match 1
Match5 - Match variable length patterns over given graphs scenarios::[17] Handling lower bounded variable length match 2
Match5 - Match variable length patterns over given graphs scenarios::[18] Handling lower bounded variable length match 3
Match5 - Match variable length patterns over given graphs scenarios::[28] Handling mixed relationship patterns 1
Match5 - Match variable length patterns over given graphs scenarios::[29] Handling mixed relationship patterns 2
Match5 - Match variable length patterns over given graphs scenarios::[26] Handling mixed relationship patterns and directions 1
Match5 - Match variable length patterns over given graphs scenarios::[4] Handling single bounded variable length match 2
Match5 - Match variable length patterns over given graphs scenarios::[5] Handling single bounded variable length match 3
Match5 - Match variable length patterns over given graphs scenarios::[9] Handling symmetrically bounded variable length match, bounds are one
Match5 - Match variable length patterns over given graphs scenarios::[10] Handling symmetrically bounded variable length match, bounds are two
Match5 - Match variable length patterns over given graphs scenarios::[1] Handling unbounded variable length match
Match5 - Match variable length patterns over given graphs scenarios::[6] Handling upper and lower bounded variable length match 1
Match5 - Match variable length patterns over given graphs scenarios::[7] Handling upper and lower bounded variable length match 2
Match5 - Match variable length patterns over given graphs scenarios::[14] Handling upper bounded variable length match 1
Match5 - Match variable length patterns over given graphs scenarios::[15] Handling upper bounded variable length match 2
Match6 - Match named paths scenarios::[6] Handling direction of named paths
Match6 - Match named paths scenarios::[9] Longer path query should return results in written order
Match6 - Match named paths scenarios::[13] Matching path with both directions should respect other directions
Match6 - Match named paths scenarios::[12] Matching path with multiple bidirectional relationships
Match6 - Match named paths scenarios::[10] Named path with alternating directed/undirected relationships
Match6 - Match named paths scenarios::[11] Named path with multiple alternating directed/undirected relationships
Match6 - Match named paths scenarios::[5] Path query should return results in written order
Match6 - Match named paths scenarios::[7] Respecting direction when matching existing path
Match6 - Match named paths scenarios::[17] Return a named var length path of length zero
Match6 - Match named paths scenarios::[2] Return a simple path
Match6 - Match named paths scenarios::[3] Return a three node path
Match6 - Match named paths scenarios::[16] Return a var length path
Match6 - Match named paths scenarios::[18] Undirected named path
Match6 - Match named paths scenarios::[20] Variable length relationship without bounds
Match6 - Match named paths scenarios::[19] Variable length relationship without lower bound
Match7 - Optional match::[26] Handling correlated optional matches; first does not match implies second does not match
Match7 - Optional match::[9] Longer pattern with bound nodes
Match7 - Optional match::[7] MATCH with OPTIONAL MATCH in longer pattern
Match7 - Optional match::[3] OPTIONAL MATCH and bound nodes
Match7 - Optional match::[23] OPTIONAL MATCH with labels on the optional end node
Match7 - Optional match::[17] Optionally matching named paths - existing result
Match7 - Optional match::[6] Optionally matching relationship with a relationship and node that are both already bound
Match7 - Optional match::[5] Optionally matching relationship with a relationship that is already bound
Match7 - Optional match::[4] Optionally matching relationship with bound nodes in reverse direction
Match7 - Optional match::[24] Optionally matching self-loops
Match7 - Optional match::[11] Return two subgraphs with bound undirected relationship and optional relationship
Match7 - Optional match::[31] Satisfies the open world assumption, relationships between different nodes
Match7 - Optional match::[29] Satisfies the open world assumption, relationships between same nodes
Match7 - Optional match::[30] Satisfies the open world assumption, single relationship
Match7 - Optional match::[12] Variable length optional relationships
Match8 - Match clause interoperation with other clauses::[2] Counting rows after MATCH, MERGE, OPTIONAL MATCH
Match8 - Match clause interoperation with other clauses::[3] Matching and disregarding output, then matching again
Match9 - Match deprecated scenarios::[6] Matching relationships into a list and matching variable length using the list, with bound nodes
Match9 - Match deprecated scenarios::[9] Optionally matching named paths with variable length patterns
Match9 - Match deprecated scenarios::[2] Return relationships by collecting them as a list - directed, one way
Match9 - Match deprecated scenarios::[4] Return relationships by collecting them as a list - undirected, starting from one extreme
Match9 - Match deprecated scenarios::[3] Return relationships by collecting them as a list - undirected, starting from two extremes
Match9 - Match deprecated scenarios::[5] Variable length pattern with label predicate on both sides
Match9 - Match deprecated scenarios::[1] Variable length relationship variables are lists of relationships
MatchWhere1 - Filter single variable::[5] Filter end node of relationship with property predicate on multi variables with multiple bindings
MatchWhere1 - Filter single variable::[6] Filter node with a parameter in a property predicate on multi variables with one binding
MatchWhere1 - Filter single variable::[1] Filter node with node label predicate on multi variables with multiple bindings
MatchWhere1 - Filter single variable::[12] Filter path with path length predicate on multi variables with one binding
MatchWhere1 - Filter single variable::[9] Filter relationship with a parameter in a property predicate on multi variables with one binding
MatchWhere1 - Filter single variable::[11] Filter relationship with disjunctive relationship type predicate on multi variables with multiple bindings
MatchWhere1 - Filter single variable::[8] Filter relationship with property predicate on multi variables with multiple bindings
MatchWhere1 - Filter single variable::[7] Filter relationship with relationship type predicate on multi variables with multiple bindings
MatchWhere1 - Filter single variable::[4] Filter start node of relationship with property predicate on multi variables with multiple bindings
MatchWhere2 - Filter multiple variables::[2] Filter node with conjunctive multi-part property predicates on multi variables with multiple bindings
MatchWhere2 - Filter multiple variables::[1] Filter nodes with conjunctive two-part property predicate on multi variables with multiple bindings
MatchWhere3 - Equi-Joins on variables::[3] Join between node properties of adjacent nodes
MatchWhere4 - Non-Equi-Joins on variables::[2] Join with disjunctive multi-part predicates including patterns
MatchWhere5 - Filter on predicate resulting in null::[4] Do not filter out on null if the OR'd predicate evaluates to true
MatchWhere5 - Filter on predicate resulting in null::[1] Filter out on null
MatchWhere5 - Filter on predicate resulting in null::[2] Filter out on null if the AND'd predicate evaluates to false
MatchWhere5 - Filter on predicate resulting in null::[3] Filter out on null if the AND'd predicate evaluates to true
MatchWhere6 - Filter optional matches::[4] Do not fail when predicates on optionally matched and missed nodes are invalid
MatchWhere6 - Filter optional matches::[1] Filter node with node label predicate on multi variables with multiple bindings after MATCH and OPTIONAL MATCH
MatchWhere6 - Filter optional matches::[3] Filter node with property predicate on multi variables with multiple bindings after OPTIONAL MATCH
MatchWhere6 - Filter optional matches::[6] Join nodes on non-equality of properties – OPTIONAL MATCH and WHERE
MatchWhere6 - Filter optional matches::[7] Join nodes on non-equality of properties – OPTIONAL MATCH on two relationships and WHERE
MatchWhere6 - Filter optional matches::[8] Join nodes on non-equality of properties – Two OPTIONAL MATCH clauses and WHERE
MatchWhere6 - Filter optional matches::[5] Matching and optionally matching with unbound nodes and equality predicate in reverse direction
Merge5 - Merge relationships::[21] Do not match on deleted relationships
Merge5 - Merge relationships::[13] Match both incoming and outgoing relationships when direction unspecified
Merge5 - Merge relationships::[3] Matching two relationships
Merge6 - Merge relationships - on create::[4] Null-setting one property with ON CREATE
Merge6 - Merge relationships - on create::[3] Updating one property with ON CREATE
Merge7 - Merge relationships - on match::[4] Copying properties from node with ON MATCH
Path2 - Relationships of a path::[1] Return relationships by fetching them from the path
Path2 - Relationships of a path::[2] Return relationships by fetching them from the path - starting from the end
Path3 - Length of a path::[1] Return a var length path of length zero
Pattern1 - Pattern predicate::[13] Fail on matching two nodes on a single undirected connection between them
Pattern1 - Pattern predicate::[2] Matching on a single undirected connection
Pattern1 - Pattern predicate::[7] Matching on a specific type of a variable length outgoing directed connection
Pattern1 - Pattern predicate::[6] Matching on a specific type of single incoming directed connection
Pattern1 - Pattern predicate::[4] Matching on a specific type of single outgoing directed connection
Pattern1 - Pattern predicate::[5] Matching on a specific type of single undirected connection
Pattern1 - Pattern predicate::[10] Matching on a specific type of undirected connection with length 2
Pattern1 - Pattern predicate::[9] Matching on a specific type of variable length incoming directed connection
Pattern1 - Pattern predicate::[8] Matching on a specific type of variable length undirected connection
Pattern1 - Pattern predicate::[3] Matching on any single incoming directed connection
Pattern1 - Pattern predicate::[1] Matching on any single outgoing directed connection
Pattern1 - Pattern predicate::[12] Matching two nodes on a single directed connection between them
Pattern1 - Pattern predicate::[16] Matching two nodes on a specific type of a variable length outgoing directed connection
Pattern1 - Pattern predicate::[14] Matching two nodes on a specific type of single outgoing directed connection
Pattern1 - Pattern predicate::[15] Matching two nodes on a specific type of single undirected connection
Pattern1 - Pattern predicate::[18] Matching two nodes on a specific type of undirected connection with length 2
Pattern1 - Pattern predicate::[17] Matching two nodes on a specific type of variable length undirected connection
Pattern1 - Pattern predicate::[19] Using a negated existential pattern predicate
Pattern1 - Pattern predicate::[20] Using two existential pattern predicates in a conjunction
Pattern1 - Pattern predicate::[21] Using two existential pattern predicates in a disjunction
Pattern2 - Pattern Comprehension::[4] Introduce a new node variable in pattern comprehension
Pattern2 - Pattern Comprehension::[5] Introduce a new relationship variable in pattern comprehension
Pattern2 - Pattern Comprehension::[1] Return a pattern comprehension
Pattern2 - Pattern Comprehension::[3] Return a pattern comprehension with bound nodes
Pattern2 - Pattern Comprehension::[2] Return a pattern comprehension with label predicate
Pattern2 - Pattern Comprehension::[11] Use a pattern comprehension and ORDER BY
Pattern2 - Pattern Comprehension::[10] Use a pattern comprehension in RETURN
Pattern2 - Pattern Comprehension::[8] Use a pattern comprehension in WITH
Pattern2 - Pattern Comprehension::[7] Use a pattern comprehension inside a list comprehension
Pattern2 - Pattern Comprehension::[9] Use a variable-length pattern comprehension in WITH
Quantifier1 - None quantifier::[9] None quantifier on list containing relationships
Quantifier2 - Single quantifier::[9] Single quantifier on list containing relationships
Quantifier3 - Any quantifier::[9] Any quantifier on list containing relationships
Quantifier4 - All quantifier::[9] All quantifier on list containing relationships
Remove1 - Remove a Property::[3] Remove a single relationship property
Remove1 - Remove a Property::[4] Remove multiple relationship properties
Remove3 - Persistence of remove clause side effects::[20] Aggregating in `RETURN` after removing a property from relationships affects the result set but not the side effects
Remove3 - Persistence of remove clause side effects::[21] Aggregating in `WITH` after removing a property from relationships affects the result set but not the side effects
Remove3 - Persistence of remove clause side effects::[19] Filtering after removing a property from relationships affects the result set but not the side effects
Remove3 - Persistence of remove clause side effects::[17] Skipping and limiting to a few results after removing a property from relationships affects the result set but not the side effects
Remove3 - Persistence of remove clause side effects::[18] Skipping zero result and limiting to all results after removing a property from relationships does not affect the result set nor the side effects
Return2 - Return single expression (correctly projecting an expression)::[14] Do not fail when returning type of deleted relationships
Return2 - Return single expression (correctly projecting an expression)::[5] Missing relationship property should become null
Return2 - Return single expression (correctly projecting an expression)::[12] Projecting a list of nodes and relationships
Return2 - Return single expression (correctly projecting an expression)::[13] Projecting a map of nodes and relationships
Return2 - Return single expression (correctly projecting an expression)::[4] Returning a relationship property value
Return3 - Return multiple expressions (if column order correct)::[3] Projecting nodes and relationships
Return4 - Column renaming::[11] Reusing variable names in RETURN
Return6 - Implicit grouping with aggregates::[16] Aggregation on complex expressions
Return6 - Implicit grouping with aggregates::[12] Counting matches per group
Return6 - Implicit grouping with aggregates::[8] Handle aggregation on functions
Return7 - Return all variables::[1] Return all variables
ReturnOrderBy1 - Order by a single variable (correct order of values according to their type)::[12] ORDER BY DESC should order distinct types in the expected order
ReturnOrderBy1 - Order by a single variable (correct order of values according to their type)::[11] ORDER BY should order distinct types in the expected order
ReturnOrderBy2 - Order by a single expression (order of projection)::[5] Support ordering by a property after being distinct-ified
ReturnSkipLimit2 - Limit::[8] Limit to more rows than actual results 2
Set1 - Set a Property::[4] Set a property by selecting the relationship using a simple expression
Set2 - Set a Property to Null::[3] Setting a relationship property to null removes the existing property
Set6 - Persistence of set clause side effects::[20] Aggregating in `RETURN` after setting a property on relationships affects the result set but not the side effects
Set6 - Persistence of set clause side effects::[21] Aggregating in `WITH` after setting a property on relationships affects the result set but not the side effects
Set6 - Persistence of set clause side effects::[19] Filtering after setting a property on relationships affects the result set but not the side effects
Set6 - Persistence of set clause side effects::[17] Skipping and limiting to a few results after setting a property on relationships affects the result set but not the side effects
Set6 - Persistence of set clause side effects::[18] Skipping zero result and limiting to all results after setting a property on relationships does not affect the result set nor the side effects
TriadicSelection1 - Query three related nodes on binary-tree graphs::[1] Handling triadic friend of a friend
TriadicSelection1 - Query three related nodes on binary-tree graphs::[11] Handling triadic friend of a friend that is a friend
TriadicSelection1 - Query three related nodes on binary-tree graphs::[12] Handling triadic friend of a friend that is a friend with different relationship type
TriadicSelection1 - Query three related nodes on binary-tree graphs::[15] Handling triadic friend of a friend that is a friend with explicit subset of relationship type
TriadicSelection1 - Query three related nodes on binary-tree graphs::[18] Handling triadic friend of a friend that is a friend with implicit subset of labels
TriadicSelection1 - Query three related nodes on binary-tree graphs::[14] Handling triadic friend of a friend that is a friend with implicit subset of relationship type
TriadicSelection1 - Query three related nodes on binary-tree graphs::[19] Handling triadic friend of a friend that is a friend with implicit superset of labels
TriadicSelection1 - Query three related nodes on binary-tree graphs::[16] Handling triadic friend of a friend that is a friend with same labels
TriadicSelection1 - Query three related nodes on binary-tree graphs::[13] Handling triadic friend of a friend that is a friend with superset of relationship type
TriadicSelection1 - Query three related nodes on binary-tree graphs::[2] Handling triadic friend of a friend that is not a friend
TriadicSelection1 - Query three related nodes on binary-tree graphs::[8] Handling triadic friend of a friend that is not a friend with different labels
TriadicSelection1 - Query three related nodes on binary-tree graphs::[3] Handling triadic friend of a friend that is not a friend with different relationship type
TriadicSelection1 - Query three related nodes on binary-tree graphs::[6] Handling triadic friend of a friend that is not a friend with explicit subset of relationship type
TriadicSelection1 - Query three related nodes on binary-tree graphs::[9] Handling triadic friend of a friend that is not a friend with implicit subset of labels
TriadicSelection1 - Query three related nodes on binary-tree graphs::[5] Handling triadic friend of a friend that is not a friend with implicit subset of relationship type
TriadicSelection1 - Query three related nodes on binary-tree graphs::[10] Handling triadic friend of a friend that is not a friend with implicit superset of labels
TriadicSelection1 - Query three related nodes on binary-tree graphs::[7] Handling triadic friend of a friend that is not a friend with same labels
TriadicSelection1 - Query three related nodes on binary-tree graphs::[4] Handling triadic friend of a friend that is not a friend with superset of relationship type
Unwind1::[12] Unwind does not remove variables from scope
With1 - Forward single variable::[3] Forwarding a relationship variable
With1 - Forward single variable::[1] Forwarind a node variable 1
With1 - Forward single variable::[2] Forwarind a node variable 2
With3 - Forward multiple expressions::[1] Forwarding multiple node and relationship variables
With4 - Variable aliasing::[1] Aliasing relationship variable
With4 - Variable aliasing::[6] Reusing variable names in WITH
With6 - Implicit grouping with aggregates::[3] Implicit grouping with multiple node and relationship variables as grouping key and single aggregation
With6 - Implicit grouping with aggregates::[4] Implicit grouping with single path variable as grouping key and single aggregation
With6 - Implicit grouping with aggregates::[2] Implicit grouping with single relationship variable as grouping key and single aggregation
With7 - WITH on WITH::[1] A simple pattern with one bound endpoint
With7 - WITH on WITH::[2] Multiple WITHs using a predicate and aggregation
WithOrderBy1 - Order by a single variable::[21] Sort distinct types in ascending order
WithOrderBy1 - Order by a single variable::[22] Sort distinct types in descending order
WithOrderBy4 - Order by in combination with projection and aliasing::[15] Sort by an aliased aggregate projection does allow subsequent matching
WithSkipLimit1 - Skip::[2] Ordering and skipping on aggregate
WithSkipLimit2 - Limit::[3] Connected components succeeding WITH with LIMIT
WithSkipLimit2 - Limit::[1] ORDER BY and LIMIT can be used
WithSkipLimit2 - Limit::[4] Ordering and limiting on aggregate
WithWhere1 - Filter single variable::[4] Filter for an unbound node variable
WithWhere1 - Filter single variable::[3] Filter for an unbound relationship variable
WithWhere2 - Filter multiple variables::[2] Filter node with conjunctive multi-part property predicates on multi variables with multiple bindings
WithWhere2 - Filter multiple variables::[1] Filter nodes with conjunctive two-part property predicate on multi variables with multiple bindings
WithWhere3 - Equi-Joins on variables::[3] Join between node properties of adjacent nodes
WithWhere4 - Non-Equi-Joins on variables::[2] Join with disjunctive multi-part predicates including patterns
WithWhere5 - Filter on predicate resulting in null::[4] Do not filter out on null if the OR'd predicate evaluates to true
WithWhere5 - Filter on predicate resulting in null::[1] Filter out on null
WithWhere5 - Filter on predicate resulting in null::[2] Filter out on null if the AND'd predicate evaluates to false
WithWhere5 - Filter on predicate resulting in null::[3] Filter out on null if the AND'd predicate evaluates to true
WithWhere6 - Filter on aggregates::[1] Filter a single aggregate
