GraphScope - graphscope blog

release-note We are pleased to introduce a range of enhancements to GraphScope with the GraphScope 0.24.0 release. This release includes a graph query engine specifically designed for high-QPS (queries per second) scenarios. It also encompasses notable features and improvements in the Interactive Engine (GIE), Learning Engine (GLE), and deployment processes.

We highlight the following improvements included in this release:

1. Graph Query Engine for High QPS

In high QPS (Queries Per Second) scenarios, the graph query engine needs to process a large number of queries within a short period of time. The performance metric that users are most concerned about is the system’s throughput. Based on GraphScope Flex, we have designed a graph query engine specifically for high QPS scenarios. This engine is currently undergoing rapid iterative development, and we welcome your feedback. The engine has the following features:

Multiple query language support: Currently, the engine supports Cypher as the query language, with plans to add support for Gremlin and GQL in the future.
High performance: Built on the Hiactor framework, it avoids context switching between threads in high-concurrency situations, thereby improving system throughput. It also supports stored procedures written in C++, further enhancing performance for specific queries.

2. Enhancements for GIE

Key Features:

Support the sample() step of Gremlin to randomly pick up a given number of traversers from a Gremlin traversal. Additionally, coin() step can now follow any step in a Gremlin traversal, instead of just V() and E(). For example,
```
g.V().sample(10)   // Sample 10 traversers from `g.V()`
g.V().out().coin(0.2)  // Randomly pick up 20% among all vertices' out neighbors
```

Support the union() step of Gremlin to combine the traversers from multiple traversals. For example,

g.V().union(out(), out().out())  // the results would now be one-hop (out once) and two-hop (out twice) neighbors of all vertices. 

Support the unfold() step of Gremlin, which is a reversed operator of fold() that flattens a collection of traversers into discrete elements. For example,
```
g.V().fold().unfold()  // must obtain `g.V()` again
```
Support the identity() step of Gremlin, which simply returns the current traversers, and is often used together with union() step. For example,
```
g.V().union(identity(), out())  // return `V()` and its one-hop neighbors
```

Support isNull in the expr() for verifying wether a certain property has NULL value. For example,

g.V().where(expr("@.age isNull"))  // the vertices without the field of `age` will be pruned

But fixes:

Fix a bug of count() step followed by order() and limit() that can cause the gaia engine to abort unexpectedly. Now the following Gremlin query can be executed smoothly:
```
g.V().order().by('id', asc).limit(1).out().count()
```

3. Enhancements for Deployment

All GraphScope images support both the x86 and arm64 platforms.
This release includes the gsctl command-line utility for building and testing GraphScope. The gsctl tool provides several commands and options to streamline the development and deployment process. You can use the following command to install the graphscope-client package and then use gsctl:

$ pip3 install graphscope-client
$ gsctl --help

4. Other Enhancements and Bug Fixes

Fix the Py_None reference count issue in GLE.
Fix the bug that GLE client only connects with a single server in distributed training.
Update the GLE-related tutorials.

For more detailed improvements that have been made in this release, please refer to the complete changelog.