memgraph/docs/user_technical/upcoming-features.md

Upcoming Features

This chapter describes some of the planned features, that we at Memgraph are working on.

Performance Improvements

Excellent database performance is one of Memgraph's long-standing goals. We will be continually working on improving the performance. This includes:

• query compilation;
• query execution;
• core engine performance;
• memory usage and
• other improvements.

Label-Property Index Usage Improvements

Currently, indexing combinations of labels and properties can be created, but cannot be deleted. We plan to add a new query language construct which will allow deletion of created indices.

Improving openCypher Support

Although we have implemented the most common features of the openCypher query language, there are other useful features we are still working on.

Map Literals

This feature would enable using ad-hoc property maps. For example, updating multiple properties on an existing node:

MATCH (node) SET node = { name: "Lamp", price: 100, color: "blue" }

Note that the same can be achieved with the current support but in a longer way:

MATCH (node) SET node.name = "Lamp", node.price = 100, node.color = "blue"

Named Paths

It would be useful to store paths that match a pattern into a variable. This enables the user to display the matched patterns or do some other operations on the path, like calculating the length of the path.

The feature would be used by simply assigning the variable to a pattern. For example:

MATCH path = (node1) -[connection]-> (node2)

Path naming is especially useful with another upcoming feature, variable length paths.

Variable Length Paths

There are cases when a user needs to find data which is connected by traversing a path of connections, but the user doesn't know how many connections need to be traversed. openCypher allows for designating patterns with variable path lengths. Matching such a path is achieved by using the * (asterisk) symbol inside the pattern for a connection. For example, traversing from node1 to node2 by following any number of connections in a single direction can be achieved with:

MATCH (node1) -[*]-> (node2)

If paths are very long, finding them could take a long time. To prevent that, a user can provide the minimum and maximum length of the path. For example, paths of length between 2 and 4 can be obtained with a query like:

MATCH (node1) -[*2..4]-> (node2)

Functions

Memgraph's openCypher implementation supports the most useful functions, but there are more which openCypher provides. Some are related to not yet implemented features like paths, while some may use the features Memgraph already supports. Out of the remaining functions, some are more useful than others and as such they will be supported sooner.

UNION

The UNION clause will offer joining the results from multiple queries. For example, finding names of :Person and :Car names.

MATCH (p :Person) RETURN p.name AS name
UNION
MATCH (c :Car) RETURN c.name AS name

List Comprehensions

List comprehensions are similar to the supported collect function, which generates a list out of multiple values. But unlike collect, list comprehensions offer a powerful mechanism for filtering or otherwise manipulating values which are collected into a list.

For example, getting numbers between 0 and 10 and squaring them:

RETURN [x IN range(0, 10) | x^2] AS squares

Another example, to collect :Person nodes with age less than 42, without list comprehensions can be achieved with:

MATCH (n :Person) WHERE n.age < 42 RETURN collect(n)

Using list comprehensions, the same can be done with the query:

MATCH (n :Person) RETURN [n IN collect(n) WHERE n.age < 42]