Ultipa Graph HTAP System (hereinafter Ultipa Graph) is a set of ultra-high performance native graph computing service framework and storage infrastructure.

Ultipa Graph product matrix contains the followings:

1. World's fastest real-time graph computing engine；
2. High performance, high availability, persistent storage services；
3. Concise and smooth user graphical operation interface and knowledge graph system;
4. Feature rich CLI toolkit；
5. High performance and flexible import/export toolkit；
6. Easy to deploy docker images；
7. SDKs and APIs of mainstream programming languages;
8. UQL - a Graph Query Language (GQL) - that this manual focuses on.

Ultipa Graph supports a rich collection of querying methods, loads of ultra-high performance graph algorithms, and real-time processing against large amounts of data, which truly saves a lot of time from user's perspective by upgrading very time consuming and non-real-time operations to real-time operations. It brings inestimable possibilities for graph computing products to be widely used in business and big data analytics scenarios.

What is UQL

Ultipa Graph Query Language, or UQL for short, is a general-purpose graph query language. UQL is a unique high-performance query and management language designed for Ultipa Graph Database and Graph Computing Engine, developers can quickly grasp it and get started with Ultipa Graph system. UQL supports query, deletion, modification, addition, graph traversal, path finding, subgraph matching, GraphSet management, schema management, property management, engine management, index management, task management, permission management, and other functions on Ultipa Graph system. Users can invoke UQL via Ultipa CLI (Command Line Tool), Ultipa Manager (a highly visualized graph database query and management interface) or Ultipa Drivers (Ultipa SDKs and APIs). UQL will soon achieve Turing Completeness and be available to developers.

Ultipa team has joined LDBC (Linked Data Benchmark Council) and is involved in the process of building the standard GQL. The GQL international standard is expected to be launched in 2024, and UQL will keep pace with this GQL standards in terms of the overall functionality and compatibility.

Terminologies

Name	Description
GQL	Graph Query Language, another and the only standard data query language since SQL (Structured Query Language).
UQL	Ultipa Graph Query Language, a kind of GQL that can fully operate Ultipa Graph system.
Node	Represents the entity in the real world, it is also called 'vertex' in graph theory.
Edge	Represents the relation between entities in the real world. An edge connects a pair of nodes, all the edges in Ultipa Graph system are directed edge (see the term 'Direction' below). The edge connecting two identical nodes is a Loop.
Metadata	The general term of node and edge.
Path	A sequence with definite initial-node and terminal-node, alternating between nodes and edges. Nodes in path can correspond while edges cannot. The sequence of IDs of the nodes and edges in a path can be regarded as the unique identifier of the path.
Intermediate Node	The nodes in a path other than the initial-node and terminal-node.
Circle	When an intermediate node of a path corresponds with any other node (including the initial-node and the terminal-node) in the path, the path is judged as 'has a circle'. The only the initial-node and the terminal-node correspond, the path will not judged as 'has a circle'. For example: (Paths that have circle can be ruled out by using the parameter no_circle() in path query command so they will not be returned.)
Shortest Path	If a path contains the least number of edges, at least one edge, to walk from its initial-node to terminal-node, it is called a shortest path of the specified initial-node and terminal-node. The 'least number of edges' should be understood as 'minimum sum of edge weights' in case of a weighted shortest path.
Graph	The dataset of nodes and edges, which is equivalent to a data collection of multiple paths that intersect. The smallest unit of graph is node, a graph is not necessarily connected.
Subgraph	A part of nodes and edges of a graph. The result of node query and path query can be considered as a subgraph.
GraphSet	Comprises the graph data (nodes and edges), along with graph model (definition of schemas and properties), property indexes, full-text indexes, engine indexes and algorithmic tasks created on the graph.
Graph System	Ultipa Graph HTAP System, a combination of graph computing engine, graph algorithm engine, full-text search engine and etc., built upon a server cluster. An Ultipa Graph system also contains GraphSets, users and policies, and the algorithm packages installed by the user.
Instance	Ultipa Graph system instances, that is, the running applications on Ultipa Server, each instance generally runs on one virtual or physical host, and multiple instances can form a cluster environment.
Schema	A schema of node or edge includes a set of properties that describes the structure and content of node or edge. Each node or edge can only belong to one schema.
Property	A property belongs to a schema and is used to describe a character of node or edge. There are system properties (see the term 'ID', 'FROM' and 'TO' below) and custom properties.
Graph Model	The definition of schemas and properties of a graph, it represents the application scenario a graph describes.
Property Index	The index created for property values and stored in the disk, to improve the query efficiency of metadata properties.
Full-text Index	The revert index created for the word-segmentation results of property values and stored in the disk, to improve the query efficiency for keywords against long strings. Ultipa self-developed full-text engine employs different dictionaries in order to optimize the word-segmentation for different datasets.
Engine Index	The property of index loaded to the computing engine (see the term 'LTE' below), to improve the efficiency of path query and deep graph traversal by reducing IO cost. The query efficiency is often increased by several orders of magnitude. Engine index is mandatory when executing inter-step comparison, inter-step filtering and calculating weighted shortest path.
Filter	Appears in parameters that represent nodes or edges in the query command, to filter nodes and edges during graph queries. Ultipa filter is essentially a logic tree, which uses conditional operators, logical operators and numeric operators to calculate operands and return True or False. Refer to the chapter Filter | Operator for details.
LTE	Load to Engine, load property to the computing engine, to create engine index.
UFE	Unload from Engine, remove property from the computing engine, to delete engine index.
Direction (In)	An edge pointing to node A from another node is called an "In" edge of node A, or an edge of node A in the inbound direction. It is written as either A<-- or -->A.
Direction (Out)	An edge pointing from node A to another node is called an "Out" edge of node A, or an edge of node A in the outbound direction. It is written as either A--> or <--A.
Direction (Left)	An edge in a given path that points from the latter node to the previous node is called "Left" edge. It is written as A<--B.
Direction (Right)	An edge in a given path that points from the previous node to the latter node is called "Right" edge. It is written as A-->B.
ID	A system property that represents the unique identifier of metadata. Includes _id of node that is string with maximum 128 bytes, and _uuid of node and edge that is uint64.
FROM	A system property that represents the ID of start node of edge. Includes _from and _from_uuid, namely the _id and _uuid of the start node.
TO	A system property that represents the ID of end node of edge. Includes _to and _to_uuid, namely the _id and _uuid of the end node.

Specification

The design inspiration of UQL has roots in a deep understanding of graph, and it satisfies the demands of industry for high dimensional and extensible graphs.

Chain Statement + Semantic Assembly + Alias Call

UQL Example:

n({_id == "CA001"}).e({time > prev_e.time})[3].n(as target)
group by target.level with count(target) as quantity
order by quantity desc
return target.level, quantity limit 10

Instructions:

• The n(... ).e(...)[3].n(...) in the above example is a chain statement styled as [command].[parameter].[parameter].... It realizes the operations of insertion, update, deletion and query. A UQL statement may contain multiple chain statements.
• The group by ..., with ..., order by ..., return ... and limit ... from the above example are clauses that process and assemble query results of a UQL.
• The query results of a UQL can also be recomputed by a function, such as the count(...) in the above example. A function should be composed in a clause.
• Query results that are temporarily saved and passed between chain statements and clauses should be given custom alias, such as target and quantity in the example. Use as to define a custom alias.
• Query results that are passed within a template are entitled with system alias, the prev_n and prev_e, to be called by an Ultipa Filter. Refer to the usage of ...time > prev_e.time... in the example.
• Supports escape characters \, tab \t, carriage return line feed \r\n and comment delimiters //, /* and */.

UQL Design Principles:

• Clearly defined advanced data structures, such as node, edge, path, attribute (atomic), array and table;
• Ability to query and acquire one or multiple of above data structures, and return and use these high dimensional results;
• Easy depict of subgraph filtering, direct docking and adaptation to high performance computing engine;
• The human brain-like grammar: chain statement + semantic assembly, requires minimal cognitive loading, easy to read, write and learn;
• The functional style is more in line with today's complex data processing needs, and provides unlimited expansion space;
• The functional style allows users to customize the extended language syntax features to meet the demands of operating complex graph;

Why Not SQL-like:

• SQL's inability to clearly express high dimensional data and its combinations, such as path, node, edge, attribute and collection of aggregation operation results;
• Path filtering in SQL is too complicated and inefficient, such as path query, template query and graph traversal;
• It is difficult to understand SQL as it is contrary to the logic of human brain, such as nested statement, table-join query, etc.

UQL Syntax Features

UQL has DQL, DDL, DML and DCL syntax features:

• DQL: Data Query Language, to query nodes, edges and paths in the graph;
• DDL: Data Definition Language, to add/delete GraphSet, modify schema, define properties, create index etc.;
• DML: Data Manipulation Language, to insert, delete and update the metadata and other content of GraphSet;
• DCL: Data Control Language, mainly used to manipulate database permission settings, such as user management, role management, grant and revoke of permissions etc.

Reserved Words

Below words are reserved by Ultipa Graph system and should NOT be used when defining schema, property and alias:

⁽¹⁾ Words that are case insensitive