What is the GQL Standard? Graph Query Language

GQL (Graph Query Language) is the new official ISO/IEC international standard for querying and managing property graph databases. Published in April 2024, it is the first new database query language standard released by ISO since SQL in 1987.

GQL is not an extension of SQL. It is its sibling.

Both languages are designed to coexist: SQL for relational data, GQL for graph-shaped data.

Key Features and Concepts

Standardization

GQL was developed by the same committee responsible for SQL (ISO/IEC JTC 1/SC 32 WG3). Its official designation is **ISO/IEC 39075:2024**.

The goal is long-term stability, portability of skills, and reduced vendor lock-in.

Property Graph Model

GQL operates on the property graph model.

Data is represented as:

• Nodes → entities (people, products, places)
• Edges → relationships between them
• Properties → key/value attributes stored on both nodes and edges
• Labels / types → categories

Think: circles connected by arrows, each carrying information.

ASCII Pattern Matching (the famous part)

One of the most recognizable aspects of GQL is how graph patterns are written.

They look like tiny diagrams made of text.

(a:Person)-[:KNOWS]->(b:Person)

Even without documentation, the intent is obvious: a person who knows another person.

Readable. Visual. Dangerous in how addictive it becomes.

Basic Query Examples

Let’s build intuition with a small social graph.

Insert data

INSERT (:Person {name: 'Alice', age: 30});
INSERT (:Person {name: 'Bob', age: 28});

INSERT (:Person {name: 'Alice'})-[:KNOWS]->(:Person {name: 'Bob'});

We created two people and a relationship.

Notice the absence of joins. Connections are first-class citizens.

Match and return

Find everyone Alice knows.

MATCH (a:Person {name: 'Alice'})-[:KNOWS]->(friend)
RETURN friend.name;

The query describes a pattern, not a navigation algorithm. The engine figures out how to execute it efficiently.

Declarative thinking at its finest.

Multi-hop traversal

Friends of friends?

MATCH (:Person {name: 'Alice'})-[:KNOWS]->()-[:KNOWS]->(fof)
RETURN DISTINCT fof.name;

Two arrows, two hops, done.

Try writing that with five joins in SQL and a cup of coffee strong enough to bend reality.

Updating Data

Change a property

MATCH (p:Person {name: 'Alice'})
SET p.age = 31;

Remove a property

MATCH (p:Person {name: 'Alice'})
REMOVE p.age;

Delete a relationship

MATCH (:Person {name: 'Alice'})-[r:KNOWS]->(:Person {name: 'Bob'})
DELETE r;

Schema Definition (DDL glimpse)

GQL is not just for querying. It can define structure too.

Example idea:

CREATE PROPERTY GRAPH TYPE SocialGraph;

CREATE NODE TYPE Person (
  name STRING,
  age INTEGER
);

CREATE EDGE TYPE KNOWS ();

Vendors may implement these pieces gradually, but the standard defines the direction.

Transactions

Like SQL, GQL supports transactional control.

START TRANSACTION;

INSERT (:Person {name: 'Carol'});

COMMIT;

Predictable. Enterprise-friendly. Boring in the best possible way.

Interoperability

GQL absorbs years of experience from languages such as openCypher, PGQL, and G-CORE.

The mission is simple:

write knowledge once, run it across platforms.

Different engines. Shared mental model.

GQL vs GraphQL

Despite the similar names, they live in different galaxies.

• GraphQL → API query language.
• GQL → database query language.

One fetches data from services. The other manipulates the storage engine itself.

GQL vs Cypher

Cypher strongly influenced the standard, but ISO GQL introduces formal semantics, stronger type systems, and features aimed at cross-vendor consistency.

Think evolution, not copy-paste.

Why This Matters

Standardization changes everything.

It enables:

• education and certifications
• tooling ecosystems
• portable skills
• vendor competition on performance instead of syntax

SQL did this for relational databases. GQL is now opening that door for graph technology.

And given how central graphs are becoming in AI, fraud detection, recommendation systems, knowledge graphs, and logistics… this is not a small historical footnote.

It’s infrastructure for the next decades.

[embed]Understanding graph databases with Neo4j

[embed]Spanner Graph: Graph databases reimagined