<p>Nebula Graph v2.0.0-beta has just been released! This version supports full-text search and counting the number of nodes and edges within a graph space. Nebula Graph Studio, the graph visualization tool, and Go Importer, the data import tool, are both compatible with Nebula Graph 2.x.</p>
<blockquote>
  <p>Note: The compatibility of schema and graph data with Nebula Graph 1.x is still under development.</p>
</blockquote>
<h2 id="post-nebula-graph">Nebula Graph</h2>
<h3 id="post-compatible-with-more-ngql-10-queries">Compatible with more nGQL 1.0 queries</h3>
<ul>
<li><code>DESCRIBE TAG/EDGE INDEX</code> is to obtain information about the index. </li>
<li><code>REBUILD TAG/EDGE INDEX</code> is to rebuild an index.</li>
<li><code>SHOW TAG/EDGE INDEXES</code> is to list the created indexes.</li>
<li><code>SHOW TAG/EDGE INDEXES STATUS</code> is to return the created index status.</li>
</ul>
<h3 id="post-new-features">New features</h3>
<ul>
<li>Full-text search, allows users to write queries that match terms anywhere within the indexed string properties.</li>
<li><code>LOOKUP ON TAG/EDGE</code> is to get all vertices of a tag or edges of an edge type.</li>
<li><code>SUBMIT JOB STATS</code>  & <code>SHOW STATS</code> is to get all vertices and edges in the current space.</li>
<li>Support more openCypher Clauses.
-- Partially supported <code>MATCH</code> clause
-- <code>RETURN</code>  & <code>DISTINCT</code>
-- <code>LIMIT</code>  & <code>SKIP</code>  </li>
<li>Add more built-in functions.
-- Predicate functions
-- Scalar functions
-- List functions
-- Aggregating functions
-- Mathematical functions
-- String functions
-- Temporal functions</li>
</ul>
<h2 id="post-clients">Clients</h2>
<ul>
<li><a href="https://github.com/vesoft-inc/nebula-clients/tree/master/cpp">CPP Client</a></li>
</ul>
<h2 id="post-nebula-graph-studio">Nebula Graph Studio</h2>
<ul>
<li>Compatible with Nebula Graph 2.x，refer to <a href="https://github.com/vesoft-inc/nebula-web-docker">Studio</a>.</li>
</ul>
<h2 id="post-tools">Tools</h2>
<ul>
<li>Go Importer: Compatible with Nebula Graph 2.x, refer to <a href="https://github.com/vesoft-inc/nebula-importer">Nebula Importer</a>.</li>
</ul>
<h2 id="post-how-to-upgrade">How to Upgrade</h2>
<p>Please note that you cannot directly upgrade to Nebula Graph v2.0.0-beta from Nebula Graph 1.x. Follow the steps below to upgrade from v2.0,0-alpha to the beta version:</p>
<ol>
<li>Stop all Nebula services <ol>
<li>Execute scripts/nebula.service stop all on each machine </li>
<li>Execute scripts/nebula.service status all to confirm all services are stopped</li></ol></li>
<li>Install the new RPM package on each machine according to the OS you are using <ol>
<li>Get package: https://github.com/vesoft-inc/nebula-graph/releases/tag/v2.0.0-beta </li>
<li>Uninstall the original RPM package <code>rpm -e nebula-graph-2.0.0-alpha.el6.x86_64.rpm</code></li>
<li>Install package: nebula-graph-2.0.0-beta.el6.x86_64.rpm</li></ol></li>
<li>Start Nebula <ol>
<li>Execute scripts/nebula.service start all on each machine </li>
<li>Execute scripts/nebula.service status all to confirm Nebula services are started on each machine</li></ol></li>
</ol>
<p>If you encounter any problem during the upgrade, please feel free to leave your comment below!</p>

Nebula Graph v2.0.0-beta has just been released! This version supports full-text search and counting the number of nodes and edges within a graph space. Nebula Graph Studio, the graph visualization tool, and Go Importer, the data import tool, are both compatible with Nebula Graph 2.x

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

Nebula Graph v2.0.0-beta 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

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.

Top 10 Use Cases for GQL in Modern Enterprises


# What is GQL?

Graph Query Language (GQL) is a specialized language designed for graph databases, paralleling the role that SQL plays in relational databases. 



## Background 

GQL is the second language in the entire database field, having undergone approximately five years from the initial establishment of the project to its final release. Initially, scholar Alastair Green found that the graph database field was fragmented, with various query languages such as  Cypher, GSQL and PGQL. Recognizing the redundancy and need for standardization, Green advocated for a unified, standardized language for querying graph databases. His proposal garnered widespread support, with over 4,000 organizations and individuals participating in a vote, resulting in a 95% approval rate for the creation of a standard language for graph database queries.In May 2024, ISO officially released ISO/IEC GQL.


## Comprehensiveness 

GQL is a comprehensive language that includes Data Manipulation Language (DML), Data Definition Language (DDL), and Data Query Language (DQL), effectively covering all necessary aspects of database operations. This capability allows GQL to support the creation, deletion, modification, and querying of graph data, as well as the definition and modification of the structure of graph databases. GQL aims to provide a unified standard for querying and managing graph databases, thereby enhancing interoperability and reducing dependency on specific graph database vendors.


# What impact will GQL have?



### Enhancing the Importance of Graph Database Technology

The establishment of GQL as a standard underscores the significance of graph database technology. Since 2013, graph databases have been at the forefront of database technology trends.According to Gartner, 80% of data and analytics innovations will use graph technologies by 2025.


### Reducing Learning and Migration Costs

The market is replete with graph database vendors, each with their own query language, leading to high learning and migration costs. GQL standardization mitigates these costs by providing a unified language, facilitating easier transitions and switches between different graph database products.


### Promoting the Application and Development of Graph Databases

Graph databases have evolved through various stages, from initial confusion about the concept to widespread recognition of their problem-solving capabilities. Today, they have proven their value in applications such as public security, recommendation systems, data selection, and supply chain manufacturing. The standardization of GQL is expected to further promote their application and development.


### Encouraging "Thinking in Graph" 

Nowadays, graph databases have passed the capability verification phase and have arrived at a critical time where they are used to think about and solve problems. GQL standardization is crucial for promoting the concept of "Thinking in Graph" , enhancing efficiency and enthusiasm for new database products and languages.


### Active Engagement from Education and Academia

Currently, numerous universities both domestically and internationally are looking to collaborate with NebulaGraph to offer courses related to GQL, preparing students who are about to enter the workforce to understand and utilize this new database language.


# What challenges will GQL face?


Despite its potential, the promotion and application of GQL will face several key challenges:



### Adaptability Challenge for Database Vendors


Database vendors each have their own unique languages and architectural systems. Faced with the implementation of the new GQL language, how will these vendors respond? Some may choose to directly adapt, converting GQL into their own proprietary languages and implementing a conversion mechanism. However, this approach could lead to a significant decrease in performance, and as GQL continues to evolve, this adaptation method may gradually fail to meet new demands. Therefore, for database vendors, aligning their graph database products with GQL is an extremely challenging task. 

But for NebulaGraph, this is merely following a trend of technological integration, as NebulaGraph has been fully committed to supporting GQL for two years. From the very beginning of GQL's proposal and formulation, NebulaGraph has been deeply involved, frequently obtaining the latest information and continuously optimizing its underlying data architecture to ensure outstanding performance when executing GQL.


### Transformation Challenge at the Application Layer

For the application layer, retrofitting existing database products to accommodate GQL presents a challenge. Graph databases are typically used in online applications that require handling a large number of real-time queries, thus demanding extremely high stability. The design logic of most application vendors is to make as few changes as possible to the existing system. Consequently, asking them to replace all query languages with GQL involves a substantial amount of work.


### Talent Reserve Issue

GQL was just released on April 12th of this year, and currently, most people have limited understanding of GQL. Learning a new language and applying it in a real-world work environment requires a considerable amount of time. Therefore, building a talent pool becomes another challenge in promoting GQL.


### Inadequacies within GQL Itself

The V1 version of GQL still has room for improvement in areas such as modifying graph types, indexes, and primary keys, and it is anticipated that future versions will address these issues. We need to allow GQL ample time to become more refined and robust, and in the meantime, we also gain more time to adapt to the requirements of GQL.


# Conclusion


In summary, GQL as the standardized language for graph databases will not only enhance the importance of graph database technology and reduce learning and migration costs but also promote the application and development of graph databases, encourage "Thinking in Graph" and gain active participation from the education and academic sectors. 

Despite the many challenges GQL will face, overall, the future of GQL is full of hope and excitement. Because when we embrace GQL, we are not just adopting a new standard; we are stepping into a future where the possibilities are as vast as the connections within a graph. We must rise to challenges and harness the collective power of innovation to unleash the full potential of GQL.

GQL is setting a new standard for graph databases, unifying query languages and simplifying operations. It promotes "Thinking in Graph," enhancing efficiency and fostering innovation. Despite challenges, GQL's future is bright, offering a dynamic path for data management.