Formalising opencypher Graph Queries in Relational Algebra

TL;DR

This paper provides a formal foundation for openCypher graph queries by defining a relational algebra extension and an algorithm for systematic query compilation, aiding standardization and interoperability.

Contribution

It introduces relational graph algebra and maps openCypher constructs to this algebra, enabling formal analysis and systematic compilation of graph queries.

Findings

Formal specification of openCypher in relational algebra

Algorithm for systematic compilation of openCypher queries

Supports standardization and interoperability of graph query languages

Abstract

Graph database systems are increasingly adapted for storing and processing heterogeneous network-like datasets. However, due to the novelty of such systems, no standard data model or query language has yet emerged. Consequently, migrating datasets or applications even between related technologies often requires a large amount of manual work or ad-hoc solutions, thus subjecting the users to the possibility of vendor lock-in. To avoid this threat, vendors are working on supporting existing standard languages (e.g. SQL) or creating standardised languages. In this paper, we present a formal specification for openCypher, a high-level declarative graph query language with an ongoing standardisation effort. We introduce relational graph algebra, which extends relational operators by adapting graph-specific operators and define a mapping from core openCypher constructs to this algebra. We propose an algorithm that allows systematic compilation of openCypher queries.

Tables

Table 1. Table 1 : Number of operands, properties and result schemas of relational graph algebra operators. A unary operator α 𝛼 \alpha is idempotent (i), iff α ​ ( x ) = α ​ ( α ​ ( x ) ) 𝛼 𝑥 𝛼 𝛼 𝑥 \alpha(x)=\alpha(\alpha(x)) for all inputs. A binary operator β 𝛽 \beta is commutative (c), iff x ​ β ​ y = y ​ β ​ x 𝑥 𝛽 𝑦 𝑦 𝛽 𝑥 x~{}\beta~{}y=y~{}\beta~{}x and associative (a), iff ( x ​ β ​ y ) ​ β ​ z = x ​ β ​ ( y ​ β ​ z ) 𝑥 𝛽 𝑦 𝛽 𝑧 𝑥 𝛽 𝑦 𝛽 𝑧 (x~{}\beta~{}y)~{}\beta~{}z=x~{}\beta~{}(y~{}\beta~{}z) . For schema transformations, append is denoted by ∥ ∥ \,\|\, , while removal is marked by ∖ \setminus . L 𝐿 L represents a (possibly empty) set of vertex labels and T 𝑇 T represents a (possibly empty) set of edge types.

#ops.	notation	name	props.	schema
0	${○}_{\left(𝚟:𝖫\right)}$	get-vertices	$-$	$⟨𝚟⟩$
1	${\updownarrow }_{\left(𝚟\right)}^{\left(𝚠:𝖫\right)}[𝚎:𝖳]\left(r\right)$	expand-both	$-$	$\mathrm{sch}\left(r\right)\parallel ⟨𝚎,𝚠⟩$
	${\not\equiv }_{\mathrm{𝗏𝖺𝗋𝗂𝖺𝖻𝗅𝖾𝗌}}\left(r\right)$	all-different	i	$\mathrm{sch}\left(r\right)$
	${\omega }_{\mathrm{𝚡𝚜}\to 𝚡}\left(r\right)$	unwind	$-$	$\mathrm{sch}\left(r\right)\setminus ⟨\mathrm{𝚡𝚜}⟩\parallel ⟨𝚡⟩$
	${\sigma }_{\mathrm{𝖼𝗈𝗇𝖽𝗂𝗍𝗂𝗈𝗇}}\left(r\right)$	selection	i	$\mathrm{sch}\left(r\right)$
	${\pi }_{{𝚡}_{\mathrm{𝟷}},{𝚡}_{\mathrm{𝟸}},\dots }\left(r\right)$	projection	i	$⟨{𝚡}_{\mathrm{𝟷}},{𝚡}_{\mathrm{𝟸}},\dots ⟩$
	${\gamma }_{{𝚡}_{\mathrm{𝟷}},{𝚡}_{\mathrm{𝟸}},\dots }^{{𝚌}_{\mathrm{𝟷}},{𝚌}_{\mathrm{𝟸}},\dots }\left(r\right)$	grouping	i	$⟨{𝚡}_{\mathrm{𝟷}},{𝚡}_{\mathrm{𝟸}},\dots ⟩$
	$\delta \left(r\right)$	duplicate-elimination	i	$\mathrm{sch}\left(r\right)$
	${\tau }_{\downarrow {𝚡}_{\mathrm{𝟷}},\uparrow {𝚡}_{\mathrm{𝟸}},\dots }\left(r\right)$	sorting	i	$\mathrm{sch}\left(r\right)$
	${\lambda }_{\mathrm{𝗌𝗄𝗂𝗉}}^{\mathrm{𝗅𝗂𝗆𝗂𝗍}}\left(r\right)$	top	$-$	$\mathrm{sch}\left(r\right)$
2	$r\cup s$	union	$-$	$\mathrm{sch}\left(r\right)$
	$r\uplus s$	bag union	c, a	$\mathrm{sch}\left(r\right)$
	$r\bowtie s$	natural join	c, a	$\mathrm{sch}\left(r\right)\parallel \left(\mathrm{sch}\left(s\right)\setminus \mathrm{sch}\left(r\right)\right)$
	$r\text{<span> </span>}\text{<span> </span>}\bowtie s$	left outer join	$-$	$\mathrm{sch}\left(r\right)\parallel \left(\mathrm{sch}\left(s\right)\setminus \mathrm{sch}\left(r\right)\right)$

Equations

$$\forall A\in \mathrm{sch}(r):\mathrm{dom}(A)\subseteq V\cup E\cup D,$$

$$L$$

$$T$$

$$P_v$$

$$P_e$$

$$V$$

$$E$$

$$st$$

$$\mathcal{L}$$

$$\mathcal{T}$$

$$\mathsf{name}$$

$$\mathsf{since}$$

$${◯}_{(\mathtt{p}:\mathsf{Person})}$$

$${\pi }_{p.name,m.language}\uparrow {}_{(\mathtt{p})}^{(\mathtt{m}:\mathsf{Message})}\left[\_e1:\mathsf{LIKES}\right]{◯}_{(\mathtt{p}:\mathsf{Person})}$$

$${\pi }_{p1,p2}/{\equiv }_{\mathtt{ks}}\updownarrow {}_{(p1)}^{(p2:\mathsf{Person})}\left[\mathtt{ks}:\mathsf{KNOWS}{\ast }_1^2\right]{◯}_{(p1:\mathsf{Person})}$$

$$/{\equiv }_{E_1,\dots ,E_n}(r)={\sigma }_{\underset{\begin{array}{c}{e}_1,e_2\in {\cup }_i{E}_i\\ e_1\ne e_2\end{array}}{\bigwedge }r.e_1\ne r.e_2}(r)$$

$${\pi }_{p1,k1,p2,k2,p3}/{\equiv }_{k1,k2}\uparrow {}_{(p2)}^{(p3)}\left[k2:\mathsf{KNOWS}\right]\uparrow {}_{(p1)}^{(p2)}\left[k1:\mathsf{KNOWS}\right]{◯}_{(p1)}$$

$$r\bowtie s={\pi }_{R\cup S}\left({\sigma }_{r.A_1=s.A_1\wedge \dots \wedge r.A_n=s.A_n)}\left(r\times s\right)\right),$$

$$\pi_{\mathtt{p1},\mathtt{p2},\mathtt{p3}}\bigg{(}\Big{(}\updownarrow\,_{(\mathtt{p1})}^{(\mathtt{p2})}\left[\mathtt{\_e1}:{\mathsf{KNOWS}}\right]\bigcirc_{(\mathtt{p1})}\Big{)}\bowtie\,\Big{(}\updownarrow\,_{(\mathtt{p2})}^{(\mathtt{p3})}\left[\mathtt{\_e2}:{\mathsf{KNOWS}}\right]\bigcirc_{(\mathtt{p2})}\Big{)}\bigg{)}$$

$${\gamma }_{\mathtt{language},count\_distinct\left(p.name\right)\to \mathtt{cnt}}^{\mathtt{language}}{\omega }_{p.speaks\to \mathtt{language}}{◯}_{(\mathtt{p}:\mathsf{Person})}$$

$${\pi }_{p.name,\mathtt{lang}}{\omega }_{p.speaks\to \mathtt{lang}}{\pi }_{\mathtt{p}}{◯}_{(\mathtt{p}:\mathsf{Person})}$$

$${\lambda }_2^1{\tau }_{\uparrow p.name}\delta {\pi }_{p.name}{◯}_{(\mathtt{p}:\mathsf{Person})}$$

Full text

In this paper, we present a formal specification for openCypher, a high-level declarative graph query language with an ongoing standardisation effort. We introduce relational graph algebra, which extends relational operators by adapting graph-specific operators and define a mapping from core openCypher constructs to this algebra. We propose an algorithm that allows systematic compilation of openCypher queries.

The final publication is available at Springer via

https://doi.org/10.1007/978-3-319-66917-5_13.

1 Introduction

1.0.1 Context.

Graphs are a well-known formalism, widely used for describing and analysing systems. Graphs provide an intuitive formalism for modelling many real-world scenarios, as the human mind tends to interpret the world in terms of objects (vertices) and their respective relationships to one another (edges) [15].

The property graph data model [17] extends graphs by adding labels/types and properties for vertices and edges. This gives a rich set of features for users to model their specific domain in a natural way. Graph databases are able to store property graphs and query their contents with complex graph patterns, which otherwise would be are cumbersome to define and/or inefficient to evaluate on traditional relational databases [21].

Neo4j111https://neo4j.com/, a popular NoSQL property graph database, offers the Cypher query language to specify graph patterns. Cypher is a high-level declarative query language which allows the query engine to use sophisticated optimisation techniques. Neo Technology, the company behind Neo4j initiated the openCypher project [13], which aims to deliver an open specification of Cypher.

1.0.2 Problem and objectives.

The openCypher project provides a formal specification of the grammar of the query language and a set of acceptance tests that define the semantics of various language constructs. This allows other parties to develop their own openCypher-compatible query engine. However, there is no mathematical formalisation for the language. In ambiguous cases, developers are advised to consult Neo4j’s Cypher documentation or to experiment with Neo4j’s Cypher query engine and follow its behaviour. Our goal is to provide a formal specification for the core features of openCypher.

1.0.3 Contributions.

In this paper, we use a formal definition of the property graph data model [7] and relational graph algebra, which operates on multisets (bags) [6] and is extended with additional graph-specific operators. Using these foundations, we construct a concise formal specification for the core features in the openCypher grammar. This specification is detailed enough to serve as a basis for an openCypher compiler [23].

2 Data Model and Running Example

2.0.1 Data model.

A property graph is defined as $G=(V,E,\mathit{st},L,T,\mathcal{L},\mathcal{T},P_{v},P_{e})$, where $V$ is a set of vertices, $E$ is a set of edges and $\mathit{st}:E\rightarrow V\times V$ assigns the source and target vertices to edges. Vertices are labelled and edges are typed:

• •

$L$ is a set of vertex labels, $\mathcal{L}:V\rightarrow 2^{L}$ assigns a set of labels to each vertex.

• •

$T$ is a set of edge types, $\mathcal{T}:E\rightarrow T$ assigns a single type to each edge.

To define properties, let $D=\cup_{i}D_{i}$ be the union of atomic domains $D_{i}$ and let $\varepsilon$ represent the NULL value.

• •

$P_{v}$ is a set of vertex properties. A vertex property $p_{i}\in P_{v}$ is a partial function $p_{i}:V\rightarrow D_{i}\cup\{\varepsilon\}$, which assigns a property value from a domain $D_{i}\in D$ to a vertex $v\in V$, if $v$ has property $p_{i}$, otherwise $p_{i}(v)$ returns $\varepsilon$.

• •

$P_{e}$ is a set of edge properties. An edge property $p_{j}\in P_{e}$ is a partial function $p_{j}:E\rightarrow D_{j}\cup\{\varepsilon\}$, which assigns a property value from a domain $D_{j}\in D$ to an edge $e\in E$, if $e$ has property $p_{j}$, otherwise $p_{j}(e)$ returns $\varepsilon$.

In the context of this paper, we define a relation as a bag (multiset) of tuples: a tuple can occur more than once in a relation [6]. Given a property graph $G$, relation $r$ is a graph relation if the following holds:

[TABLE]

where the schema of $r$, $\mathrm{sch}(\mathit{r})$, is a list containing the attribute names, $\mathrm{dom}(A)$ is the domain of attribute $A$, $V$ is the vertices of $G$, and $E$ is the edges of $G$.

2.0.2 Property access.

When defining relational algebra expression on graph relations, it is often required (e.g. in projection and selection operators) to access a certain property of a vertex/edge. Following the notation of [7], if $x$ is an attribute of a graph relation, we use $x.p$ to access the corresponding value of property $p$. Also, $\mathcal{L}(v)$ returns the labels of vertex $v$ and $\mathcal{T}(e)$ returns the type of edge $e$.

2.0.3 Running example.

An example graph inspired by the LDBC Social Network Benchmark [5] is shown on 1(a), while 1(b) presents the formalised graph. The graph vertices model four Persons and three Messages, with edges representing LIKES, REPLY_OF and KNOWS relations. In social networks, the KNOWS relation is symmetric, however, the property graph data model does not allow undirected edges. Hence, we use directed edges with an arbitrary direction and model the symmetric semantics of the relation in the queries.

3 The openCypher Query Language

Cypher is the a high-level declarative graph query language of the Neo4j graph database. It allows users to specify graph patterns with a syntax resembling an actual graph, which makes the queries easy to comprehend. The goal of the openCypher project [13] is to provide a standardised specification of the Cypher language. In the following, we introduce features of the language using examples.

3.1 Language Constructs

3.1.1 Inputs and outputs.

openCypher queries take a property graph as their input, however the result of a query is not a graph, but a graph relation.

3.1.2 Vertex and path patterns.

The basic building blocks of queries are patterns of vertices and edges. LABEL:lst:get-vertices shows a query that returns all vertices that model a Person. The query in LABEL:lst:expand-out matches Person and Message pairs connected by a LIKES edge and returns the person’s name and the message language. LABEL:lst:multihop describes person pairs that know each other directly or have a friend in common, i.e. from person $\mathsf{p1}$, the other person $\mathsf{p2}$ can be reached using one or two hops.

3.1.3 Filtering.

Pattern matches can be filtered in two ways as illustrated in LABEL:lst:selection1 and LABEL:lst:selection2. (1) Vertex and edge patterns in the MATCH clause might have vertex label/edge type constraints written in the pattern after a colon, and (2) the optional WHERE subclause of MATCH might hold predicates.

3.1.4 Unique and non-unique edges.

A MATCH clause defines a graph pattern. A query can be composed of multiple patterns spanning multiple MATCH clauses. For matches of a pattern within a single MATCH clause, edges are required to be unique. However, matches for multiple MATCH clauses can share edges. This means that in matches returned by LABEL:lst:alldifferent, $\mathsf{k1}$ and $\mathsf{k2}$ are required to be different, while in matches returned by LABEL:lst:non-unique-edges, $\mathsf{k1}$ and $\mathsf{k2}$ are allowed to be equal. For vertices, this restriction does not apply.222Requiring uniqueness of edges is called edge isomorphic matching. Other query languages and execution engines might use vertex isomorphic matching (requiring uniqueness of vertices), isomorphic matching (requiring uniqueness of both vertices and edges) or homomorphic matching (not requiring uniqueness of either) [8]. This is illustrated in LABEL:lst:triangle, which returns adjacent persons who like the same message.

3.1.5 Creating the result set.

The result set333The term result set refers to the result collection, which can be a set, a bag or a list. of a query is basically given in the RETURN clause, which can be de-duplicated using the DISTINCT modifier, sorted using the ORDER BY subclause. Skipping rows after sorting and limiting the result set to a certain number of records can be achieved using SKIP and LIMIT modifiers.

LABEL:lst:duplicate-elimination-sorting illustrates these concepts by returning the name of the persons. The result set is restricted to the second and third names in alphabetical order.

3.1.6 Combining patterns.

Multiple patterns (in the same or in different) MATCH clauses are combined together based on their common variables. LABEL:lst:join illustrates this by showing two patterns on lines 2 and 3. The first pattern describes a message $\mathsf{m}$ that has at least two likes. The second pattern finds replies to $\mathsf{m}$.

3.1.7 Aggregation.

openCypher specifies aggregation operators for performing calculations on multiple tuples.444The avg, count, max, min, percentileCont, percentileDisc, stdDev, stdDevP, sum functions return a single scalar value, while collect returns a list. Unlike in SQL queries, the grouping criteria is determined implicitly in the RETURN as well as in and WITH clauses. Each expression of the expression list in WITH and RETURN are forced to contain either (1) no aggregate functions or (2) a single aggregate function at the outermost level. The grouping key is the tuple built from expressions of type (1).555Decision on grouping semantics is due after the camera ready submission deadline. The semantics presented in this paper is one of the possible approaches. The query of LABEL:lst:grouping counts the number of persons commanding each language.

3.1.8 Unwinding a list.

The UNWIND construct takes an attribute and multiplies each tuple by appending the list elements one by one to the tuple, thus modifying the schema of the query part. By applying UNWIND to the $\mathsf{speaks}$ attribute LABEL:lst:unwind lists persons along the languages they speak. Fig. 2 shows the output of this query. As Cecil speaks two languages, he appears twice in the output. Note that “Daisy” speaks no languages, thus no tuples belong to her in the output.

3.2 Query Structure

In openCypher a query is composed as the UNION of one or more single queries. Each single query must have the same resulting schema, i.e. the resulting tuples must have the same arity and the same name at each position.

3.2.1 Single queries.

A single query is composed of one or more query parts written subsequently. Query parts that form a prefix of a single query have one result set with the schema of the last query part’s schema in that prefix.

3.2.2 Query parts.

Clause sequence of a query part matches the regular expression as follows: MATCH*((WITH UNWIND?)|UNWIND|RETURN). They begin with an arbitrary number of MATCH clauses, followed by either (1) WITH and an optional UNWIND, (2) a single UNWIND, or (3) a RETURN in case of the last query part.666In openCypher, the filtering WHERE operation is a subclause of MATCH and WITH. When used in WITH as illustrated on line 3 of LABEL:lst:multiple-subqueries, WHERE is similar to the HAVING construct of SQL with the major difference that, in openCypher it is also allowed when no aggregation was specified in the query.

The RETURN and WITH clauses use similar syntax and have the same semantics, the only difference being that RETURN should be used in the last query part while WITH should only appear in the preceding ones. These clauses list expressions whose value form the tuples, thus they determine the schema of the query parts.

3.2.3 Example.

An openCypher single query composed of two query parts is shown on LABEL:lst:multiple-subqueries along with its result on Fig. 3. It retrieves the language of messages that were written in a language no other message uses. If that message was a reply, the language of the original message is also retrieved.

The first query part spans lines 1–3 and the second spans lines 4–6. The result of the first query part is a single tuple $\langle\mathsf{``fr"},1\rangle$ with the schema $\langle\mathsf{singleLang},\mathsf{cnt}\rangle$. The second query part takes this result as an input to retrieve messages of the given languages and in case of a reply the original message in $\mathsf{m3}$. The result of these two query parts together produces the final result whose schema is determined by the RETURN of the last query part (line 6).

4 Mapping openCypher to Relational Graph Algebra

In this section, we present relational graph algebra using the examples of Sec. 3.1 and provide a mapping that allows compilation from openCypher to this algebra.

4.1 An Algebra for Formalising Graph Queries

We present both standard operators of relational algebra [4] and operators for graph relations. Tab. 1 provides an overview of the operators of relational graph algebra. We follow the openCypher query language and present a mapping from the language constructs to their algebraic equivalents777Patterns in the openCypher query might contain anonymous vertices and edges. In the algebraic form, we denote this with names starting with an underscore, such as $\mathtt{\_v1}$ and $\mathtt{\_e2}$., summarized in Tab. 2. The corresponding rows of the table (e.g.
Tab. 2 ) are referred to in the text.

4.1.1 Basic operators.

The projection operator $\pi$ keeps a specific set of attributes in the relation: $t=\pi_{\mathtt{x_{1}},\ldots,\mathtt{x_{n}}}\left(r\right).$ Note that the tuples are not deduplicated (i.e. filtered to sets), thus $t$ will have the same number of tuples as $r$. The projection operator can also rename the attributes, e.g. $\pi_{\mathtt{x1}\rightarrow\mathtt{y1}}\left(r\right)$ renames $\mathtt{x1}$ to $\mathtt{y1}$.

The selection operator $\sigma$ filters the incoming relation according to some criteria. Formally, $t=\sigma_{\theta}\left(r\right),$ where predicate $\theta$ is a propositional formula. Relation $t$ contains all tuples from $r$ for which $\theta$ holds.

4.1.2 Vertices and patterns.

Tab. 2

– Tab. 2 The get-vertices [7] nullary operator $\bigcirc_{(\mathtt{v}:{\mathsf{l_{1}\land\ldots\land l_{n}}})}$ returns a graph relation of a single attribute $v$ that contains vertices that have all of labels $l_{1},\ldots,l_{n}$. Using this operator, the query in LABEL:lst:get-vertices is compiled to

[TABLE]

Tab. 2

– Tab. 2 The expand-out unary operator $\uparrow\,_{(\mathtt{v})}^{(\mathtt{w}:{\mathsf{l_{1}\land\ldots\land l_{n}}})}\left[\mathtt{e}:{\mathsf{t_{1}\lor\ldots\lor t_{k}}}\right](r)$ adds new attributes $e$ and $w$ to each tuple iff there is an edge $e$ from $v$ to $w$, where $e$ has any of types $t_{1},\ldots,t_{k}$, while $w$ has all labels $l_{1},\ldots,l_{n}$.888Label and type constraints can be omitted for the get-vertices operator and the expand operators. For example, $\bigcirc_{(\mathtt{v})}$ returns all vertices, while $\uparrow\,_{(\mathtt{v})}^{(\mathtt{w})}\left[\mathtt{e}\right](r)$ traverses all outgoing edges $e$ from vertices $v$ to $w$, regardless of their labels/types. More formally, this operator appends the $\langle e,w\rangle$ to a tuple iff $\mathit{st}(e)=\langle v,w\rangle$, $l_{1},\ldots,l_{n}\in\mathcal{L}(w)$ and $\mathcal{T}(e)\in\{t_{1},\ldots,t_{k}\}$. Using this operator, the query in LABEL:lst:expand-out can be formalised as

[TABLE]

Similarly to the expand-out operator, the expand-in operator $\downarrow$ appends $\langle e,w\rangle$ iff $\mathit{st}(e)=\langle w,v\rangle$, while the expand-both operator $\updownarrow$ uses edge $e$ iff either $\mathit{st}(e)=\langle v,w\rangle$ or $\mathit{st}(e)=\langle w,v\rangle$. We also propose an extended version of this operator, $\uparrow\,_{(\mathtt{v})}^{(\mathtt{w})}\left[\mathtt{e}\ast_{\mathsf{min}}^{\mathsf{max}}\right]$, which may use between $\mathsf{min}$ and $\mathsf{max}$ hops. Using this extension, LABEL:lst:multihop is compiled to

[TABLE]

4.1.3 Combining and filtering pattern matches.

Tab. 2

– Tab. 2 In order to express the uniqueness criterion for edges (illustrated in subsubsection 3.1.4) in a compact way, we propose the all-different operator. The all-different operator $\not\equiv_{E_{1},\ldots,E_{n}}{(r)}$ filters $r$ to keep tuples where variables in $\cup_{i}E_{i}$ are pairwise different. Note that the operator is actually a shorthand for the following selection:

[TABLE]

Using the all-different operator, query in LABEL:lst:alldifferent is compiled to

[TABLE]

Tab. 2

– Tab. 2 The result of the natural join operator $\bowtie$ is determined by creating the Cartesian product of the relations, then filtering those tuples which are equal on the attributes that share a common name. The combined tuples are projected: from the attributes present in both of the two input relations, we only keep the ones in $r$ and drop the ones in $s$. Thus, the join operator is defined as

[TABLE]

where $\{A_{1},\ldots,A_{n}\}=R\cap S$ is the set of attributes that occur both in $R$ and $S$.

In order to allow pattern matches to share the same edge, they must be included in different MATCH clauses as shown on LABEL:lst:non-unique-edges which is compiled to

[TABLE]

The query in LABEL:lst:join with two patterns in one MATCH clause is compiled to:

[TABLE]

Tab. 2

Tab. 2 The

left outer joinoperatorproducest = r   ⋈s$combiningmatchingtuplesof$r$and$s$accordingtoagivenmatchingsemantics.Incasethereisnomatchingtuplein$999Matching semantics might use value equality of attributes that share a common name (similarly to natural join) to use an arbitrary condition (similarly to $\theta$-join).s$foraparticulartuple$e ∈r,e$isstillincludedintheresult,withtupleattributesthatexclusivelybelongtorelation$s$havingavalueof$ε.

4.1.4 Result and subresult operations.

Tab. 2

The duplicate-elimination operator $\delta$ eliminates duplicate tuples in a bag.

Tab. 2

The grouping operator $\gamma$ groups tuples according to their value in one or more attributes and aggregates the remaining attributes.

We generalize the grouping operator to explicitly state the grouping criteria and allow for complex aggregate expressions. This is similar to the SQL query language where the grouping criteria is explicitly given in GROUP BY.

We use the notation $\gamma_{e_{1},e_{2},\ldots}^{c_{1},c_{2},\ldots}$, where $c_{1},c_{2},\ldots$ in the superscript form the grouping criteria, i.e. the list of expressions whose values partition the incoming tuples into groups. For each and every group this aggregation operator emits a single tuple of expressions listed in the subscript, i.e. $\langle e_{1},e_{2},\ldots\rangle$. Given attributes $\{a_{1},\ldots,a_{n}\}$ of the input relation, $c_{i}$ is an arithmetic expression built from $a_{j}$ attributes using common arithmetic operators, while $e_{i}$ is an expression built from $a_{j}$ using common arithmetic operators and grouping functions.

We have discussed the aggregation semantics of openCypher in subsubsection 3.1.7. The formal algorithm for determining the grouping criteria is given in Alg. 1. Building on this algorithm and the grouping operator, LABEL:lst:grouping is compiled to

[TABLE]

4.1.5 Unwinding and list operations.

Tab. 2

The unwind [3] operator $\omega_{\mathtt{xs}\rightarrow\mathtt{x}}$ takes the list in attribute $\mathtt{xs}$ and multiplies each tuple adding the list elements one by one to an attribute $\mathtt{x}$, as demonstrated in Fig. 2. Using this operator, the query in LABEL:lst:unwind can be formalised as

[TABLE]

Tab. 2

The sorting operator $\tau$ transforms a bag relation of tuples to a list of tuples by ordering them. The ordering is defined for selected attributes and with a certain direction for each of them (ascending $\uparrow$/descending $\downarrow$), e.g. $\tau_{\uparrow\mathtt{x1},\downarrow\mathtt{x2}}(r)$.

Tab. 2

The top operator $\lambda_{l}^{s}$ (adapted from [11]) takes a list as its input, skips the first $s$ tuples and returns the next $l$ tuples.101010SQL implementations offer the OFFSET and the LIMIT/TOP keywords.

Using the sorting and top operators, the query of LABEL:lst:duplicate-elimination-sorting is compiled to:

[TABLE]

4.1.6 Combining results.

The $\cup$ operator produces the set union of two relations, while the $\uplus$ operator produces the bag union of two operators, e.g. $\{\langle 1,2\rangle,\langle 3,4\rangle\}\uplus\{\langle 1,2\rangle\}=\{\langle 1,2\rangle,\langle 1,2\rangle,\langle 3,4\rangle\}$. For both the union and bag union operators, the schema of the operands must have the same attributes.

4.2 Mapping openCypher Queries to Relational Graph Algebra

In this section, we give the mapping algorithm of openCypher queries to relational graph algebra and also give a more detailed listing of the compilation rules for the query language constructs in Tab. 2. We follow a bottom-up approach to build the relational graph algebra expression.

Process each single query as follows and combine their result using the union operation. As the union operator is technically a binary operator, the union of more than two single queries are represented as a left-deep tree of UNION operators. 2. 2.

For each query part of a single query, denoted by $t$, the relational graph algebra tree built from the prefix of query parts up to—but not including—the current query part, process the current query part as follows.

A single pattern is turned left-to-right to a get-vertices for the first vertex and a chain of expand-in, expand-out or expand-both operators for inbound, outbound or undirected relationships, respectively. 2. 2.

Comma-separated patterns in a single MATCH are connected by natural join. 3. 3.

Append an all-different operator for all edge variables that appear in the MATCH clause because of the non-repeating edges language rule. 4. 4.

Process the WHERE subclause of a single MATCH clause. 5. 5.

Several MATCH clauses are connected to a left-deep tree of natural join.

For OPTIONAL MATCH, left outer join is used instead of natural join. In case there is a WHERE subclause, its condition becomes part of the join condition, i.e. it will never filter on the input from previous MATCH clauses. 6. 6.

If there is a positive or negative pattern deferred from WHERE processing, append it as a natural join or a combination of left outer join and selection operator filtering on no matches were found, respectively. 7. 7.

If this is not the first query part, combine the curent query part with the relational graph algebra tree of the preceding query parts by appending a natural join here. Its left operand will be $t$ and its right operand will be the relational graph algebra tree built so far from the current subquery. 8. 8.

Append grouping, if RETURN or WITH clause has grouping functions inside. 9. 9.

Append a projection operator based on the RETURN or WITH clause. This operator will also handle the renaming (i.e. AS). 10. 10.

Append a duplicate-elimination operator, if the RETURN or WITH clause has the DISTINCT modifier. 11. 11.

Append a selection operator if WITH had the optional WHERE subclause.

4.3 Summary and Limitations

In this section, we presented a mapping that allows us to express the example queries of Sec. 3.1 in graph relational algebra. We extended relational algebra by adapting operators ($\bigcirc$, $\uparrow$, $\tau$, $\lambda$), precisely specifying grouping semantics ($\gamma$) and defining the all-different operator ($\not\equiv$). Finally, we proposed an algorithm for compiling openCypher graph queries to graph relational algebra.

Our mapping does not completely cover the openCypher language. As discussed in Sec. 3, some constructs are defined as legacy and thus were omitted. The current formalisation does not include expressions (e.g. conditions in selections) and maps. Compiling data manipulation operations (such as CREATE, DELETE, SET, and MERGE) to relational algebra is also subject of future work.

5 Related Work

5.0.1 Property graph data models.

The TinkerPop framework aims to provide a standard data model for property graphs, along with Gremlin, a high-level imperative graph traversal language [16] and the Gremlin Structure API, a low-level programming interface.

5.0.2 EMF.

The Eclipse Modeling Framework is an object-oriented modelling framework widely used in model-driven engineering. Henshin [1] provides a visual language for defining patterns, while Epsilon [9] and Viatra Query [2] provide high-level declarative (textual) query languages, the Epsilon Pattern Language and the Viatra Query Language.

5.0.3 SPARQL.

Widely used in semantic technologies, SPARQL is a standardised declarative graph pattern language for querying RDF [24] graphs. SPARQL bears close similarity to Cypher queries, but targets a different data model and requires users to specify the query as triples instead of graph vertices/edges [14]. G-SPARQL [19] extended the SPARQL language for attributed graphs, resulting in a language with an expressive power similar to openCypher.

5.0.4 SQL.

In general, relational databases offer limited support for graph queries: recursive queries are supported by PostgreSQL using the WITH RECURSIVE keyword and by the Oracle Database using the CONNECT BY keyword. Graph queries are supported in the SAP HANA prototype [18], through a SQL-based language [10].

5.0.5 Cypher.

Due to its novelty, there are only a few research works on the formalisation of (open)Cypher. The authors of [7] defined graph relations and introduced the GetNodes, ExpandIn and ExpandOut operators. While their work focused on optimisation transformations, this paper aims to provides a more complete and systematic mapping from openCypher to relational algebra.

In [8], graph queries were defined in a Cypher-like language and evaluated on Apache Flink. However, formalisation of the queries was not discussed in detail.

5.0.6 Comparison of graph query frameworks.

Previously, we published the Train Benchmark, a framework for comparing graph query frameworks across different technological spaces, such as property graphs, EMF, RDF and SQL [21].

6 Conclusion and Future Work

In this paper, we presented a formal specification for a subset of the openCypher query language. This provides the theoretical foundations to use openCypher as a language for graph query engines.

As future work, we plan to provide a formalisation based on graph-specific theoretical query frameworks, such as [12]. We will also give the formal specification of the operators for incremental query evaluation, which requires the definition of maintenance operations that keep the result in sync with the latest set of changes [22]. Our long-term research objective is to design an openCypher-compatible distributed, incremental graph query engine [20].111111Our prototype, ingraph, is available at: http://docs.inf.mit.bme.hu/ingraph/

Acknowledgements

Gábor Szárnyas and Dániel Varró were supported by the MTA-BME Lendület Research Group on Cyber-Physical Systems and the NSERC RGPIN-04573-16 project. The authors would like to thank Gábor Bergmann and János Maginecz for their comments on the draft of this paper.