GQL (Graph Query Language) is a standardized query language for property graphs first described in ISO/IEC 39075, released in April 2024 by ISO/IEC.
History The GQL project is the culmination of converging initiatives dating back to 2016, particularly a private proposal from Neo4j to other database vendors in July 2016, and a proposal from Oracle technical staff within the ISO/IEC JTC 1 standards process later that year.
2019 GQL project proposal In September 2019 a proposal for a project to create a new standard graph query language (ISO/IEC 39075 Information Technology — Database Languages — GQL) was approved by a vote of national standards bodies which are members of ISO/IEC Joint Technical Committee 1(ISO/IEC JTC 1). JTC 1 is responsible for international Information Technology standards. GQL is intended to be a declarative database query language, like SQL.
The 2019 GQL project proposal states:
Official ISO standard
The GQL standard, ISO/IEC 39075:2024 Information technology – Database languages – GQL, was officially published by ISO on 12 April 2024.
GQL project organisation The GQL project is led by Stefan Plantikow (who was the first lead engineer of Neo4j's Cypher for Apache Spark project) and Stephen Cannan (Technical Corrigenda editor of SQL). They are also the editors of the initial early working drafts of the GQL specification.
As originally motivated, the GQL project aims to complement the work of creating an implementable normative natural-language specification with supportive community efforts that enable contributions from those who are unable or uninterested in taking part in the formal process of defining a JTC 1 International Standard. In July 2019 the Linked Data Benchmark Council (LDBC) agreed to become the umbrella organization for the efforts of community technical working groups. The Existing Languages and the Property Graph Schema working groups formed in late 2018 and early 2019 respectively. A working group to define formal denotational semantics for GQL was proposed at the third GQL Community Update in October 2019.
ISO/IEC JTC 1/SC 32 WG3 Seven national standards bodies (those of the United States, China, Korea, the Netherlands, the United Kingdom, Denmark and Sweden) have nominated national subject-matter experts to work on the project, which is conducted by Working Group 3 (Database Languages) of ISO/IEC JTC 1's Subcommittee 32 (Data Management and Interchange), usually abbreviated as ISO/IEC JTC 1/SC 32 WG3, or just WG3 for short. WG3 (and its direct predecessor committees within JTC 1) has been responsible for the SQL standard since 1987.
ISO stages
date ISO stages 2019-09-10 10.99 New project approved 2019-09-10 20.00 New project registered in TC/SC work programme 2021-11-22 30.00 Committee draft (CD) registered 2021-11-23 30.20 CD study initiated 2022-02-25 30.60 Close of comment period 2022-08-29 30.92 CD referred back to Working Group 2022-08-29 30.00 Committee draft (CD) registered 2022-08-30 30.20 CD study initiated 2022-10-26 30.60 Close of comment period 2023-03-22 30.99 CD approved for registration as DIS 2023-03-24 40.00 DIS registered 2023-05-24 40.20 DIS ballot initiated: 12 weeks 2023-08-17 40.60 Close of voting 2023-11-28 40.99 Full report circulated: DIS approved for registration as FDIS 2023-12-11 50.00 Final text received or FDIS registered for formal approval 2024-01-26 50.20 Proof sent to secretariat or FDIS ballot initiated: 8 weeks 2024-03-23 50.60 Close of voting. Proof returned by secretariat 2024-03-23 60.00 International Standard under publication 2024-04-12 60.60 International Standard published 2025-12-15 10.99 Technical Corrigendum 1
GQL property graph data model
GQL is a query language specifically for property graphs. A property graph closely resembles a conceptual data model, as expressed in an entity–relationship model or in a UML class diagram (although it does not include n-ary relationships linking more than two entities). Entities are modelled as nodes, and relationships as edges, in a graph. Property graphs are multigraphs: there can be many edges between the same pair of nodes. GQL graphs can be mixed: they can contain directed edges, where one of the endpoint nodes of an edge is the tail (or source) and the other node is the head (or target or destination), but they can also contain undirected (bidirectional or reflexive) edges.
Nodes and edges, collectively known as elements, have attributes. Those attributes may be data values, or labels (tags). Values of properties cannot be elements of graphs, nor can they be whole graphs: these restrictions intentionally force a clean separation between the topology of a graph, and the attributes carrying data values in the context of a graph topology. The property graph data model therefore deliberately prevents nesting of graphs, or treating nodes in one graph as edges in another. Each property graph may have a set of labels and a set of properties that are associated with the graph as a whole.
GQL queries operate by pattern matching over this structure. Nodes are written in parentheses, optionally with labels and properties, and relationships are written in square brackets between nodes with optional direction and type. Query results are produced by matching graph patterns and returning variables bound to nodes, edges, or paths.
Current graph database products and projects often support a limited version of the model described here. For example, Apache Tinkerpop forces each node and each edge to have a single label; Cypher allows nodes to have zero to many labels, but relationships only have a single label (called a reltype). Neo4j's database supports undocumented graph-wide properties, Tinkerpop has graph values which play the same role, and also supports "metaproperties" or properties on properties. Oracle's PGQL supports zero to many labels on nodes and on edges, whereas SQL/PGQ supports one to many labels for each kind of element. The NGSI-LD information model specified by ETSI is an attempt at formally specifying property graphs, with node and relationship (edge) types that may play the role of labels in previously mentioned models and support semantic referencing by inheriting classes defined in shared ontologies.
The GQL project will define a standard data model, which is likely to be the superset of these variants, and at least the first version of GQL is likely to permit vendors to decide on the cardinalities of labels in each implementation, as does SQL/PGQ, and to choose whether to support undirected relationships.
Additional aspects of the ERM or UML models (like generalization or subtyping, or entity or relationship cardinalities) may be captured by GQL schemas or types that describe possible instances of the general data model.
Implementations The first in-memory graph database that can interpret GQL is available. Aside from the implementation, one can also find a formalization and read the syntax of the specific subset of GQL.
Extending existing graph query languages The GQL project draws on multiple sources or inputs, notably existing industrial languages and a new section of the SQL standard. In preparatory discussions within WG3 surveys of the history and comparative content of some of these inputs were presented. GQL is a declarative language with its own distinct syntax, playing a similar role to SQL in the building of a database application. Other graph query languages have been defined which offer direct procedural features such as branching and looping (Apache Tinkerpop's Gremlin), and GSQL, making it possible to traverse a graph iteratively to perform a class of graph algorithms, but GQL will not directly incorporate such features. However, GQL is envisaged as a specific case of a more general class of graph languages, which share a graph type system and a calling interface for procedures that process graphs.
SQL/PGQ Prior work by WG3 and SC32 mirror bodies, particularly in INCITS Data Management (formerly INCITS DM32), has helped to define a new Part 16: Property Graph Queries (SQL/PGQ) of the SQL:2023 Standard, which allows a read-only graph query to be called inside a SQL SELECT statement, matching a graph pattern using syntax which is very close to Cypher, PGQL and G-CORE, and returning a table of data values as the result. SQL/PGQ also contains DDL to allow SQL tables to be mapped to a graph view schema object with nodes and edges associated to sets of labels and set of data properties. The GQL project coordinates closely with the SQL/PGQ "project split" of (extension to) ISO 9075 SQL, and the technical working groups in the U.S. (INCITS DM32) and at the international level (SC32/WG3) have several expert contributors who work on both projects. The GQL project proposal mandates close alignment of SQL/PGQ and GQL, indicating that GQL will in general be a superset of SQL/PGQ.
More details about the pattern matching language can be found in the paper "Graph Pattern Matching in GQL and SQL/PGQ"
Cypher Cypher is a language originally designed by Andrés Taylor and colleagues at Neo4j Inc., and first implemented by that company in 2011. Since 2015 it has been made available as an open source language description with grammar tooling, a JVM front-end that parses Cypher queries, and a Technology Compatibility Kit (TCK) of over 2000 test scenarios, using Cucumber for implementation language portability. The TCK reflects the language description and an enhancement for temporal datatypes and functions documented in a Cypher Improvement Proposal.
Cypher allows creation, reading, updating and deleting of graph elements, and is a language that can therefore be used for analytics engines and transactional databases.
Querying with visual path patterns Cypher uses compact fixed- and variable-length patterns which combine visual representations of node and relationship (edge) topologies, with label existence and property value predicates. (These patterns are usually referred to as "ASCII art" patterns, and arose originally as a way of commenting programs which used a lower-level graph API.) By matching such a pattern against graph data elements, a query can extract references to nodes, relationships and paths of interest. Those references are emitted as a "binding table" where column names are bound to a multiset of graph elements. The name of a column becomes the name of a "binding variable", whose value is a specific graph element reference for each row of the table.
For example, a pattern will generate a two-column output table. The first column named will contain references to nodes with a label . The second column named will contain references to nodes with a label , denoting the city where the person lives.
The binding variables and can then be dereferenced to obtain access to property values associated with the elements referred to by a variable. The example query might be terminated with a , resulting in a complete query like this:
MATCH (p:Person)-[:LIVES_IN]->(c:City) RETURN p.first_name, p.last_name, c.name, c.state This would result in a final four-column table listing the names of the residents of the cities stored in the graph.
Pattern-based queries are able to express joins, by combining multiple patterns which use the same binding variable to express a natural join using the clause:
MATCH (p:Person)-[:LIVES_IN]->(c:City), (p:Person)-[:NATIONAL_OF]->(EUCountry) RETURN p.first_name, p.last_name, c.name, c.state This query would return the residential location only of EU nationals.
An outer join can be expressed by :
MATCH (p:Person)-[:LIVES_IN]->(c:City) OPTIONAL MATCH (p:Person)-[:NATIONAL_OF]->(ec:EUCountry) RETURN p.first_name, p.last_name, c.name, c.state, ec.name This query would return the city of residence of each person in the graph with residential information, and, if an EU national, which country they come from.