<p><img src="https://user-images.githubusercontent.com/56643819/74008741-96befe00-49bc-11ea-8a68-3a2d2dd42182.png" alt="Release note" /></p>
<p>Main features and fixes for this release include  <code>dump_tools</code>&nbsp;to export data by specific filters, graph data exploring tool NebulaGraph Studio, and vertex/edge scan interface for OLAP scenarios. &nbsp;</p>
<p>Below is a list of details.</p>
<h2 id="post-query-engine">Query engine</h2>
<ul>
<li>Support fetching all props of a given vertex <a href="https://github.com/vesoft-inc/nebula/pull/1486">#1486</a></li>
<li>Support <code>DELETE EDGE</code> to delete the given edge <a href="https://github.com/vesoft-inc/nebula/pull/1063">#1063</a></li>
<li>Add <code>IF EXISTS</code>&nbsp;to&nbsp;conditionally drop a tag/edgetype only if  it exists. <a href="https://github.com/vesoft-inc/nebula/pull/1505">#1505</a></li>
<li>Add <code>IF NOT EXISTS</code> to conditionally&nbsp;create a space/tag/edge&nbsp;only if  it not exists <a href="https://github.com/vesoft-inc/nebula/pull/1379">#1379</a></li>
<li>Export graphd metrics <a href="https://github.com/vesoft-inc/nebula/pull/1451">#1451</a></li>
</ul>
<h2 id="post-storage">Storage</h2>
<ul>
<li>Add scan edge/vertex interface to retrieve data from storage for OLAP, <a href="https://github.com/vesoft-inc/nebula/pull/1381">#1381</a></li>
<li>Support&nbsp;<code>heartbeat_interval_secs</code> option to config heartbeat interval between storage/graph and meta <a href="https://github.com/vesoft-inc/nebula/pull/1540">#1540</a></li>
<li>Pushdown&nbsp;filter to minimize data transfer and improve query performance <a href="https://github.com/vesoft-inc/nebula/pull/947">#947</a></li>
<li>Support local conf mode, using local conf rather than config in meta server <a href="https://github.com/vesoft-inc/nebula/pull/1411">#1411</a></li>
<li>Add timeout for storage/meta clients, the default value is 60s and configured by <code>meta_client_timeout_ms</code>&nbsp;option <a href="https://github.com/vesoft-inc/nebula/pull/1399">#1399</a></li>
<li>Support creating a snapshot for the whole cluster <a href="https://github.com/vesoft-inc/nebula/pull/1199">#1199</a> <a href="https://github.com/vesoft-inc/nebula/pull/1372">#1372</a></li>
<li>Both support reading from leader/follow and support only read from the leader  <a href="https://github.com/vesoft-inc/nebula/pull/1363">#1363</a></li>
<li>Add check step for each balance task during balancing process. <a href="https://github.com/vesoft-inc/nebula/pull/1378">#1378</a></li>
</ul>
<h2 id="post-build">Build</h2>
<ul>
<li>Simplify the build process, support most of Linux Kernel 2.6.32+ system <a href="https://github.com/vesoft-inc/nebula/pull/1332">#1332</a></li>
</ul>
<h2 id="post-index">Index</h2>
<ul>
<li>Support create an index，get a list of all indexes in the space and drop an index <a href="https://github.com/vesoft-inc/nebula/pull/1459">#1459</a> &nbsp;<a href="https://github.com/vesoft-inc/nebula/pull/1360">#1360</a></li>
</ul>
<h2 id="post-tools">Tools</h2>
<ul>
<li><code>dump_tools</code>&nbsp;, an off-line data dumping tool that can be used to dump or count data with specified conditions. <a href="https://github.com/vesoft-inc/nebula/pull/1479">#1479</a> &nbsp;<a href="https://github.com/vesoft-inc/nebula/pull/1554">#1554</a></li>
<li><code>Spark Writer</code>&nbsp;adopts async client，add hash and uuid support，support load data into the same schema from different data source <a href="https://github.com/vesoft-inc/nebula/pull/1405">#1405</a> <a href="https://github.com/vesoft-inc/nebula/pull/1512">#1512</a>.</li>
<li><code>Spark Writer</code>&nbsp;supports configuring Spark partition，more numerous partitions allow work to be distributed among more workers, however, fewer partitions allow work to be done in larger chunks (and often quicker). <a href="https://github.com/vesoft-inc/nebula/pull/1412">#1412</a></li>
</ul>
<h2 id="post-ui">UI</h2>
<ul>
<li>NebulaGraph Studio is the graphical user interface for working with Nebula. Query, visualize nebula and import CSV data to Nebula. Visualize and explore graph data via the interface; an editor with syntax highlighting feature enables users to design queries fast and view query results in a structured manner; support data import via GUI. Here's the repo of this tool (including documentation and deployment files): https://github.com/vesoft-inc/nebula-web-docker</li>
</ul>
<h2 id="post-you-might-also-like">You might also like</h2>
<ol>
<li><a href="https://nebula-graph.io/posts/nebula-graph-rc2-release-note/">NebulaGraph RC2 Release Note</a></li>
<li><a href="https://nebula-graph.io/posts/nebula-graph-rc4-release-note/">NebulaGraph RC4 Release Note</a></li>
</ol>

Check what’s new in NebulaGraph’s RC3 release: NebulaGraph Studio 1.0 Beta for data visualization, index, Spark Writer, and much more.

Features

System-testing

Dev-log

Performance

Use-cases

Community

Deployment

Tools

Query-language

Graph-computing

Tech-talk

Release-notes

Architecture

News

Source-code

Success-stories

Knowledge-graph

NebulaGraph RC3 Release Note

Benchmarking the Mainstream Open Source Distributed Graph Databases at Meituan: NebulaGraph vs Dgraph vs JanusGraph

Graph Database vs Relational Database: What to Choose?

Difference Between Relational and Non Relational Database

Use cases of graph databases in real-time recommendation

SQL (Structured Query Language) has been the standard language for managing and querying relational databases for decades. Relational databases store data in tables and use structured schemas to define relationships between these tables. However, with the increasing complexity of data relationships in modern applications, there has been a growing need to model and query data in ways that go beyond traditional tabular structures.

Graph databases, such as Neo4j, Amazon Neptune, and NebulaGraph, have emerged to address these needs by storing data as nodes (entities) and edges (relationships). They are optimized for traversing and querying complex relationships, making them ideal for applications like social networks, recommendation engines, fraud detection, and network analysis.

In response to the rising popularity of graph databases and the demand for more flexible data modeling, several major SQL database systems have introduced support for graph queries. This includes the ability to create, manage, and query graph structures directly within a SQL database, leveraging the familiar syntax and capabilities of SQL. 

This introduction does bring benefits to organizations looking for unified data management as both relational and graph data can be managed within the same database system, simplifying their data architecture and reducing the need for multiple specialized databases. However, it does not necessarily mean that graph databases will no longer be needed or that they will be replaced. 
Here are several key points to consider regarding the impact of this development on graph databases:

# Data Model Complexity and Flexibility
The graph database is a natural fit for graph data. If the data inherently represents complex relationships and networks (e.g., social networks, knowledge graphs), a graph database provides a more natural and intuitive way to model and query the data. What’s more, graph databases offer more flexibility in evolving the data model. In relational databases, schema changes can be complex and disruptive, whereas graph databases allow for more dynamic and flexible schema evolution.

# Query Language and Usability
Graph databases often provide specialized query languages (e.g., Cypher for Neo4j, Gremlin for TinkerPop) that are designed specifically for graph traversal and pattern matching, making it easier to express complex queries. Since the ISO-GQL was officially released in April this year, the graph database industry is expecting this standard graph query language to provide a unified and standard experience for developers familiar with graph concepts, as using a standard graph-specific query language, can be more intuitive and efficient compared to using SQL extensions for graph queries.

# Real-Time Analytics and Insights
For applications requiring real-time insights and analytics, such as fraud detection or recommendation engines, graph databases are optimized for low-latency query execution and can handle real-time data updates and queries more effectively. Some graph databases are designed to integrate seamlessly with streaming data sources, enabling real-time graph updates and analytics. Apparently, under situations requiring real-time analytics and insights, even though relational databases can perform graph queries, they may not be ideal options.

# Scalability and Distributed Processing
In terms of scalability and distributed processing, relational databases with graph query support might not be competitive to dedicated graph databases. Many graph databases are designed to scale horizontally, distributing data and queries across multiple nodes in a cluster, for instance NebulaGraph. This can be particularly important for large-scale graph applications where the data volume and query complexity require distributed processing. Besides, dedicated graph databases often come with built-in, optimized graph algorithms (e.g., shortest path, centrality, community detection) that can be executed efficiently at scale. 

# Complementary Use Cases
Graph databases are optimized specifically for graph data and queries, offering advanced features such as efficient graph traversals, pattern matching, and handling of complex relationships. While SQL databases with graph query support can handle basic graph operations, dedicated graph databases are likely to remain superior for use cases that require high performance and scalability in graph processing. Therefore, SQL databases with graph capabilities and dedicated graph databases can coexist, each serving different needs and use cases.

# Performance Considerations
While SQL databases with graph query support can handle graph data, they might not match the performance and efficiency of dedicated graph databases, especially for large-scale graph processing and real-time analytics. Graph databases are designed with specific optimizations for graph workloads, such as index-free adjacency, which can significantly improve query performance for certain types of graph operations.

# Conclusion
In summary, while the support for graph queries in SQL databases enhances their capabilities and provides more flexibility, it does not render dedicated graph databases obsolete. Each type of database has its strengths and is suited for different use cases. Organizations will continue to choose the best tool for their specific requirements, and dedicated graph databases will remain crucial for applications that demand high-performance graph processing and advanced graph analytics. The coexistence of these technologies provides organizations with a broader range of tools to meet their diverse data management needs.

While the support for graph queries in SQL databases enhances their capabilities and provides more flexibility, it does not render dedicated graph databases obsolete.

Graph Databases vs. SQL with Graph Queries: Friends or Foes?

GQL, a property graph query language newly released this year by the ISO, is the second international standard database query language since SQL's debut over 40 years ago. It integrates the strengths of Cypher, SQL, and various general programming languages, making it a powerful tool for analyzing complex graph data.

# Building on Cypher: How GQL Enhances Graph Queries

## Enhanced Graph Pattern Matching

### Powerful Label Matching Syntax

One of the standout features of GQL is its advanced label matching syntax. This allows for more complex queries using logical operators such as `&`, `|`, and `!`.

In Cypher, a typical query might look like this:

```
MATCH (n:Person)
WHERE n.age > 30
RETURN n
```

With GQL, you can perform more sophisticated queries:

```
MATCH (n:Manager & FullTime | !Intern)
WHERE n.age > 30
RETURN n.name AS managerName, n.department AS dept
```

This GQL query finds nodes that are both `Manager` and `FullTime`, or not `Intern`, and have an age greater than 30.

### Regex-like Variable-Length Path Pattern

GQL introduces a regex-like syntax for variable-length patterns, enhancing flexibility in path matching. Examples include `-[e]->{1,3}`, `-[e]->+`, `-[e]->*`, and` -[e]->?`. This allows for more complex path pattern matching compared to Cypher’s syntax.

### Path Restrictors

GQL provides four path restrictors—`WALK`,`TRAIL`,`ACYCLIC`, and `SIMPLE`—to control whether paths can have repeated nodes or edges.

### Path Selectors

GQL offers versatile shortest path queries, including options for finding all shortest paths, any shortest path, and the top k shortest paths. This flexibility allows for detailed and efficient path retrieval in various scenarios.

## Modern Variable Definition

### Local Variable Definition

GQL introduces a dedicated syntax for defining local variables at the beginning of a procedure, similar to early C language practices. These variables are visible throughout the entire procedure scope. The introduction of local variables allows GQL to express nonlinear data flows, enabling data to be reused multiple times.

For instance, when users need to perform multiple analyses on the same dataset, GQL's local variables provide an efficient way to store and reuse intermediate results. This is particularly useful for complex calculations or when the same base data needs to be processed in different ways.

Consider a scenario where we want to analyze user interactions in a social network:

```
TABLE userActivity = {
    MATCH (u:User)-[a:ACTION]->()
    RETURN u.id AS userId, a.timestamp AS actionTime, a.type AS actionType
}
 
VALUE activeUsers = VALUE {
    FOR i IN userActivity
    WHERE i.actionTime > datetime('2024-01-01')
    RETURN collect_list(DISTINCT i. userId)
}
 ​
VALUE uniqueActionTypes = VALUE {
    FOR i IN userActivity
    WHERE i.userId IN activeUsers
    RETURN count(DISTINCT i.actionType) AS uniqueActionTypes
}
```

In this example,` userActivity` captures the base dataset of user actions, which is then reused to identify active users and calculate action statistics. This demonstrates how GQL's local variables enable efficient data reuse and modular query construction.

### The LET Statement: Another Way to Define Variables

The LET statement in GQL defines variables by adding a new column to the current output table, unlike VALUE, which creates procedure-scope visible variables. LET is non-blocking, allowing you to define new variables without interrupting the flow of existing ones, unlike Cypher’s WITH, which requires manual inclusion.

In Cypher, you must explicitly pass all existing variables when defining a new one:

```
MATCH (v)-[e]->(v2)
WITH v, e, v2, 1 AS a
```

Or use `WITH *` to retain all:

```
MATCH (v)-[e]->(v2)
WITH *, 1 AS a
```

In GQL, `LET` simplifies this process:

```
MATCH (v)-[e]->(v2)
LET a = 1
```

Here, `v`, `e`, and `v2` remain accessible, and `a` is seamlessly added. This makes `LET` a more efficient and intuitive choice for variable definition.

## Complex Nested Queries

GQL's `CALL` statement allows you to encapsulate a set of statements into a subquery block, treating them as a single unit that can be referenced by outer statements. This is particularly useful when you need to apply operations on the combined results of multiple queries.

For example, to sort the combined results of two different queries:

```
CALL {
    MATCH (v:Person) RETURN v.name AS name
    UNION
    MATCH (v:City) RETURN v.name AS name
}
ORDER BY name
```

The `CALL` block enables the `ORDER BY` to be applied to the unioned results, rather than just the last query.

# Comparison between GQL and SQL/PGQ

SQL/PGQ extends its graph query capabilities based on SQL, and it shares a read-only graph pattern matching syntax with GQL. However, compared to SQL/PGQ, GQL provides a complete set of read-write syntax, which can better meet the various operation requirements of graph databases.

In addition, although SQL is powerful, its syntax design has some well-known issues. For example, the clause order of SQL is not intuitive and difficult to combine, and users often need to use workarounds to achieve complex requirements. Google recently published an article titled "SQL Has Problems. We Can Fix Them: Pipe Syntax In SQL," pointing out these syntax design issues of SQL and proposing a special pipeline operator aimed at making clauses more linear and combinable, thereby enhancing the flexibility and intuitiveness of SQL.

GQL, on the other hand, is inherently linear and composable. It features orthogonal statements like `MATCH` for graph pattern matching, `FILTER ` for filtering results, `FOR ` for iterating over lists, `LET` for variable definitions, and CALL for complex nested queries.

In addition, GQL includes `INSERT`, `SET` and other DML statements, which can be also elegantly combined in a linear manner with DQL statements.

For example, you can match nodes and then insert an edge between them:

```
MATCH (a:player{id:1, name:"Tim"}(b:player{id:2, name:"Jerry"})
INSERT (a)-[:follow{followness:90}]->(b)
```

The following two figures intuitively demonstrate the differences in syntax between SQL and GQL.

**Figure 1: SQL's Rigid Clause Structure**

![](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/74ac57c6f7a292190fc6b1ff2b10139f.png)

**Figure 2: GQL's Linear Statement Composition**

![](https://nebula-website-cn.oss-cn-hangzhou.aliyuncs.com/nebula-website-5.0/share/c5ab0435a24e95b58f87f65bde9d2103.png)

# Looking Forward: The Road Ahead for GQL

The first version of GQL has already included numerous features, showcasing the outstanding contributions of the standard committee members. Personally, I look forward to the possibility of future developments such as subgraph extraction, diverse table construction methods, window functions, and advanced programming constructs like conditional statements, loop statements, and lambda expressions. These enhancements will further solidify GQL's role as a powerful and user-friendly query language。

As a modern, advanced data query language, GQL excels in functionality and ease of use, making it essential for industries managing vast networks, such as telecommunications and social media. Its capability for real-time analytics provides immediate insights, which is crucial for decision-making in dynamic environments. Looking ahead, GQL's ongoing development promises to shape how we interact with data, paving the way for innovations in AI, healthcare, logistics, and beyond.

In conclusion, GQL is set to transform data management, and we eagerly anticipate its future advancements.


GQL, ISO's new graph query language, boosts complex data analysis with advanced pattern matching and versatile queries, vital for network-intensive industries.

Unveiling ISO-GQL: The Future of Graph Query Languages

In today's rapidly evolving business landscape, modern enterprises are constantly seeking innovative solutions to stay competitive and drive success. One of the most significant advancements in data management and analytics this year has been the release of [the first ISO-GQL standard on April 12](https://www.nebula-graph.io/posts/nebulagraph_enterprise_5.0_gql_support). This groundbreaking development in the graph database industry introduces a standardized graph query language, unifying the querying of graph databases and offering immense potential for enterprises.

# Why ISO-GQL is Important to Modern Enterprises

ISO-GQL's release is particularly relevant as it directly addresses several critical factors that underpin the success of modern enterprises. By providing a universal querying language, ISO-GQL ensures consistency and interoperability across different graph database platforms, which is crucial for data-driven decision-making. The efficiency of ISO-GQL in traversing and querying complex networks supports agility and innovation, allowing businesses to quickly adapt to market changes and innovate continuously.

ISO-GQL provides a standardized graph query language that unifies the querying of graph databases, which is crucial for several reasons:

- Standardization: ISO-GQL offers a universal querying language that ensures consistency and interoperability across different graph database platforms.
- Efficiency: Designed specifically for graph data, ISO-GQL enables efficient traversal and querying of complex networks, which is essential for applications requiring deep link analysis.
- Flexibility: ISO-GQL supports flexible data modeling, allowing enterprises to represent and query intricate relationships without the constraints of traditional relational databases.
- Scalability: Graph databases using ISO-GQL can scale horizontally, handling large volumes of interconnected data with ease.
Future-Proofing: Adopting ISO-GQL positions enterprises to stay ahead of technological advancements and industry standards, ensuring long-term compatibility and support.

# Top 10 Use Cases for GQL in Modern Enterprises
## 1. Property Graph Model
ISO-GQL defines a property graph model where nodes (vertices) and edges (relationships) can have properties (key-value pairs) associated with them. In social network analysis, platforms use property graphs to represent users (nodes) and their interactions (edges), with properties like user demographics and interaction types, facilitating detailed analysis of user behavior and network dynamics. LinkedIn uses property graphs to model its professional network, representing users as nodes and connections as edges with properties like job titles, companies, and skills. This allows LinkedIn to efficiently manage and query vast amounts of user data, providing personalized job recommendations and networking suggestions. This capability enables detailed and scalable modeling of complex relationships, enhancing data-driven decision-making and personalized user experiences.

## 2. Graph Pattern Matching (GPM)
ISO-GQL supports complex graph pattern matching, enabling users to specify intricate patterns to search within the graph data. In fraud detection, financial institutions can use GPM to identify suspicious transaction patterns, such as circular payment schemes or unusual connections between accounts, helping to uncover fraudulent activities. For example, JPMorgan Chase uses graph pattern matching to detect fraud by identifying suspicious transaction patterns and relationships between accounts. By analyzing these patterns, the bank can proactively prevent fraudulent activities. This enhances security and compliance by enabling the detection of complex fraud patterns and anomalies in real-time.
## 3. Query Performance and Optimization (QPP)

ISO-GQL includes mechanisms for query performance and optimization, ensuring efficient execution of complex queries. In e-commerce, platforms can optimize recommendation queries to provide real-time, personalized product suggestions to users, enhancing the shopping experience and increasing sales. Amazon optimizes product recommendation queries to provide real-time, personalized suggestions to users based on their browsing and purchase history. This improves customer satisfaction and drives sales by delivering fast, relevant recommendations and insights.

## 4. Data Manipulation

ISO-GQL allows for the creation, updating, and deletion of graph data, enabling dynamic and real-time data management. In IT infrastructure management, companies use data manipulation capabilities to continuously update the status and relationships of IT components, ensuring an accurate and current view of the infrastructure. Netflix uses data manipulation to continuously update its content library and user preferences, ensuring that recommendations are always current and relevant. This supports dynamic and agile data management, allowing enterprises to respond quickly to changing data and user needs.
## 5. Multi-Graph Joint Query
ISO-GQL supports querying across multiple graphs, allowing for the integration and analysis of data from different sources. In healthcare data integration, providers can perform joint queries across patient records, treatment data, and research databases to derive comprehensive insights for personalized patient care. Pfizer performs joint queries across clinical trial data, patient records, and research databases to derive comprehensive insights for drug development and personalized medicine. This facilitates comprehensive data integration and analysis, leading to better-informed decisions and innovative solutions.
## 6. Undirected Graph Support
ISO-GQL supports undirected graphs, which are useful for scenarios where the direction of relationships is not significant. In telecommunications network optimization, undirected graphs can represent symmetrical relationships between network nodes, helping to optimize network performance and reliability. This enhances network optimization and reliability, ensuring robust and efficient communication infrastructures.
## 7. Path Queries
ISO-GQL allows querying for paths between nodes, including shortest paths, all paths, and paths with specific constraints. In supply chain management, companies, such as DHL, use path queries to find the most efficient routes for transporting goods, considering factors like distance, cost, and time, thereby optimizing logistics and reducing costs.
## 8. Schema Flexibility
ISO-GQL supports flexible schema definitions, allowing for dynamic and evolving data models without rigid schemas. In enterprise search, organizations can continuously update and integrate new types of data from various sources, ensuring a comprehensive and up-to-date information retrieval system. Google uses schema flexibility to continuously update and integrate new types of data from various sources into its knowledge graph, enhancing search accuracy and relevance. This supports agile and adaptive data management, enabling enterprises to evolve their data models as needed.
## 9. Declarative Syntax
ISO-GQL provides a declarative query language, making it easier for users to specify what they want to retrieve without detailing how to retrieve it. In enterprise search, employees can use simple and intuitive queries to search across integrated knowledge graphs, retrieving relevant information quickly and accurately without needing deep technical knowledge. Salesforce uses declarative syntax to allow users to easily query customer relationship data, generating insights and reports without needing deep technical expertise. This empowers business users to access and analyze data independently, improving productivity and decision-making.
## 10. ACID Compliance
ISO-GQL ensures ACID (Atomicity, Consistency, Isolation, Durability) compliance, providing reliable transaction processing. In financial services, banks rely on ACID compliance to ensure the integrity and consistency of transactions, even in the event of system failures, thus maintaining trust and reliability in their operations.

# Conclusion
The technical characteristics of ISO-GQL, such as the Property Graph Model, Graph Pattern Matching, Query Performance and Optimization, and others, provide powerful capabilities for managing and querying graph data. These features enable modern enterprises to address complex data challenges across various domains, from fraud detection and social network analysis to supply chain management and IT infrastructure monitoring. By adopting ISO-GQL, enterprises can leverage the full potential of their graph databases, driving innovation, efficiency, and competitive advantage.

[NebulaGraph, as the first distributed graph database with native GQL support, empowers enterprises to unlock the full potential of their data and stay ahead in a competitive landscape.](https://www.nebula-graph.io/posts/enterprise_5.0_GA_announcement) If you’re interested in taking a trial, feel free to [contact us](https://www.nebula-graph.io/contact).


The ISO-GQL release introduces a standardized graph query language, unifying the querying of graph databases and offering immense potential for enterprises.