View source for Vol-2599/CKG2019 paper 2

=Paper=

{{Paper
|id=Vol-2599/CKG2019_paper_2
|wikidataid=Q117337585
|title=Formalizing Gremlin Pattern Matching Traversals in an Integrated Graph Algebra
|pdfUrl=https://ceur-ws.org/Vol-2599/CKG2019_paper_2.pdf
|dblpUrl=https://dblp.org/rec/conf/semweb/ThakkarAV19
|volume=Vol-2599
|storemode=property
|authors=Harsh Thakkar,Sören Auer,Maria-Esther Vidal
|description=scientific paper
}}
=Freitext=
==Formalizing Gremlin Pattern Matching Traversals in an Integrated Graph Algebra==
<pdf width="1500px">https://ceur-ws.org/Vol-2599/CKG2019_paper_2.pdf</pdf>
<pre>
        Formalizing Gremlin Pattern Matching
       Traversals in an Integrated Graph Algebra

               Harsh Thakkar1 , Sören Auer1,2 , Maria-Esther Vidal2
           1
               Smart Data Analytics Lab (SDA), University of Bonn, Germany
                   2
                      TIB & Leibniz University of Hannover, Germany
                  {lastname}@cs.uni-bonn.de1 , dpunjani@di.uoa.gr2



        Abstract. Graph data management (also called NoSQL) has revealed
        beneficial characteristics in terms of flexibility and scalability by differ-
        ently balancing between query expressivity and schema flexibility. This
        peculiar advantage has resulted into an unforeseen race of developing new
        task-specific graph systems, query languages and data models, such as
        property graphs, key-value, wide column, resource description framework
        (RDF), etc. Present-day graph query languages are focused towards flex-
        ible graph pattern matching (aka sub-graph matching), whereas graph
        computing frameworks aim towards providing fast parallel (distributed)
        execution of instructions. The consequence of this rapid growth in the
        variety of graph-based data management systems has resulted in a lack
        of standardization. Gremlin, a graph traversal language, and machine
        provide a common platform for supporting any graph computing sys-
        tem (such as an OLTP graph database or OLAP graph processors). In
        this extended report, we present a formalization of graph pattern match-
        ing for Gremlin queries. We also study, discuss and consolidate various
        existing graph algebra operators into an integrated graph algebra.


 Keywords: Graph Pattern Matching, Graph Traversal, Gremlin, Graph
 Algebra



 1    Introduction

 Upon observing the evolution of information technology, we can observe
 a trend from data models and knowledge representation techniques be-
 ing tightly bound to the capabilities of the underlying hardware towards
 more intuitive and natural methods resembling human-style information
 processing. This evolution started with machine assembly languages, went
 over procedural programming, object-oriented methods and resulted in an
 ever more loosely coupling of data and code with relational data bases,
 declarative query languages and object-relational mapping (ORM). In re-
 cent years, we can observe an even further step in this evolution – graph




Copyright c 2019 for this paper by its authors. Use permitted under Creative Com-
mons License Attribution 4.0 International (CC BY 4.0).
�based data models, which organize information in conceptual networks.
Graphs are valued distinctly, when it comes to choosing formalisms for
modelling real-world scenarios such as biological, transport, communica-
tion and social networks due to their intuitive data model. In particular,
the property graph data model is capable of representing complex domain
networks [17].
    Graph analysis tools have turned out to be one of pioneering applica-
tions in understanding these natural and man-made networks [7]. Graph
analysis is carried out using graph processing techniques which ultimately
boil down to efficient graph query processing. Graph Pattern Matching
(GPM), also referred to as the sub-graph matching is the foundational
problem of graph query processing. Many vendors have proposed a vari-
ety of (proprietary) graph query languages to demonstrate the solvability
of graph pattern matching problem.
    These modern graph query languages focus either on traversal, where
traversers move over vertices and edges of a graph in a user defined fash-
ion or on pattern-matching, where graph patterns are matched against the
graph database. Gremlin [16] is one such modern graph query language,
with a distinctive advantage over others that it offers both of these per-
spectives. This implies that a user can reap benefits of both declarative
and imperative matching style within the same framework. Furthermore,
conducting GPM in Gremlin can be of crucial importance in cases such
as:
 – Querying very large graphs, where a user is not completely aware of
   certain dataset-specific statistics of the graph (e.g., the number of
   created vs knows edges existing in the graph (ref. Figure 1));
 – Creating optimal query plans, without the user having to dive deep
   into traversal optimization strategies.
 – In application-specific settings such as a question answering [26], users
   express information needs (e.g., natural language questions) which can
   be better represented as graph pattern matching problems than path
   traversals.
In this work, we present an extended version of our earlier work [25] that
contributes to establishing a formal base for a graph query algebra, by
surveying and integrating existing graph query operators. The contribu-
tions of this work are in particular:
 – We consolidate existing graph algebra operators from the literature
   and propose two new traversal operators into an integrated graph
   algebra.

                                     2
� – We formalize the graph pattern matching construct of the Gremlin
   query language.
 – We provide a formal specification of pattern matching traversals for
   the Gremlin language, which can serve as a foundation for implement-
   ing a Gremlin based query compilation engine.
    As a result, the formalization of graph query algebra supports the
integration and interoperability of different graph data models [5] (e.g.,
executing SPARQL queries on top of Gremlin [23,24]), helps to prevent
vendor lock in scenarios and boosts data management benchmarking ef-
forts such as LITMUS [10,21,22] and the Linked Data Benchmark Council
(LDBC) [2].
    The remainder of this article is organised as follows: section 2 describes
the preliminaries including property graphs, graph pattern matching, and
foundations of relational algebra. section 3 elaborates on Gremlin as a
traversal language and machine, and discusses synergy of GPM and its
evaluation in Gremlin. section 4 proposes the Gremlin to graph algebra
mapping algorithm. section 5 surveys related work. In section 6 we con-
clude this article and discuss future work.

2     Preliminaries

In this section, we present and summarise the mathematical concepts
used in this article. Our notation closely follows [9] and extends [18] by
adding the notion of vertex labels.

2.1      Property Graphs
Property graphs, also referred to as directed, edge-labeled, attributed
multi-graphs, have been formally defined in a wide variety of texts, such
as [1,8,11,17,15]. We adapt the definition of property graphs presented
by [17]:
Definition 1 (Property Graph). A property graph is defined as G =
{V, E, λ, µ}; where:
 – V is the set of vertices,
 – E is the set of directed edges such that E ⊆ (V × Lab × V ) where Lab
   is the set of Labels,
 – λ is a function that assigns labels to the edges and vertices (i.e. λ :
   V ∪ E → Σ ∗ )3 , and
3
    set of strings (Σ ∗ )


                                      3
�Fig. 1. Running example. This figure presents a collaboration network scenario of
employees in a typical software company, There are 6 vertices (with labels ”person”
and ”software”) and 6 edges connecting them with two type of relations (i.e., edge
labels) namely, ”created” and ”knows”.


 – µ is a partial function that maps elements and keys to values (i.e.
   µ : (V ∪ E) × R → S) i.e. properties (key r ∈ R, value s ∈ S).   t
                                                                    u
   For simplicity, we define disparate sets (of µ and λ) for the labels and
properties of vertices and edges respectively, adapting the terminology
used in [9]. We define:
 – Lv : Set of vertex labels (Lv ⊂ Σ ∗ ), λl : V → Lv assigns label to each
   vertex
 – Le : Set of edge labels (Le ⊂ Σ ∗ ), λe : E → Le assigns label to each
   edge. (Lv ∩ Le = φ , Lv ∪ Le = Lab; wrt definition 1, λ = λv ∪ λe )
 – Pv :Set of vertex properties (Pv ⊂ R), µv : V × Pv → S assigns a value
   to each vertex property
 – Pe : Set of edge properties (Pe ⊂ R), µe : E × Pe → S assigns a
   value to each edge property (Pv 6= Pe ; in the context of definition 1,
   µ = µv ∪ µe )
   Figure 1, presents a visualization of the Apache TinkerPop modern
crew graph4 . We use this graph as a running example throughout this
paper.

2.2    Graph Pattern Matching
Graph Pattern Matching (GPM) is a computational task consisting of
matching graph patterns (P ) against a graph (G, ref. def. 1). Graph
4
    TinkerPop Modern Crew property graph (http://tinkerpop.apache.org/docs/3.
    2.3/reference/#intro)


                                        4
�Fig. 2. We illustrate the notion of a sample, (a) basic graph pattern and (b) complex
graph pattern, as a gremlin traversal over the graph G as shown in Figure 1.



databases perform GPM for querying a variety of data models such as
RDF, Property Graphs, edge-labelled graphs, etc., and many works ad-
dress and analyze its solvability, such as [1,8,11,13,27]. Various graph
query languages have been implemented for querying these data models,
that are of imperative and declarative nature, such as:

 – The SPARQL5 query language for RDF triple stores (declarative),
 – Neo4J’s native query language CYPHER6 (declarative),
 – Apache TinkerPop’s graph traversal language and machine Grem-
   lin 7 (a functional language traditionally imperative, but also offers
   a declarative construct).

GPM queries can represented by two types of graph patterns [1], basic
graph patterns (BGP) and complex graph patterns (CGP), which add
operations such as projections, unions, etc. to BGPs (cf. Figure 2).

Example 1. For the graph pattern (say P ) as shown in Figure 2(b), as
per the Definition 1 of property graphs, we have that P = {V, E, λ, µ},
where Figure 3 demonstrates the values of its components.

    A GPM is evaluated by matching, a sub-graph pattern over a graph G.
Matching has been formally defined in various texts and we summarise
a formal definition in our context which closely follows the definition
provided by [8,1].
5
  https://www.w3.org/TR/rdf-sparql-query/
6
  https://neo4j.com/developer/cypher-query-language/
7
  https://tinkerpop.apache.org/


                                         5
�      Fig. 3. Demonstrating the components of the CGP shown in Figure 2(b).



Definition 2 (Match of a graph pattern). A graph pattern P =
(Vp , Ep , λp , µp ); is matching the graph G = (V, E, λ, µ), iff the following
conditions are satisfied:

1. there exist mappings µp and λp such that, all variables are mapped
   to constants, and all constants are mapped to themselves (i.e. λp ∈
   λ, µp ∈ µ),
2. each edge é ∈ Ep in P is mapped to an edge e ∈ E in G, each vertex
   v́ ∈ Vp in P is mapped to a vertex v ∈ V in G, and
3. the structure of P is preserved in G (i.e. P is a sub-graph of G) t
                                                                     u

We discuss matching graph patterns, over a graph G, in the context of
Gremlin traversal language in Section 3.2.

Example 2. We illustrate the evaluation of graph patterns (a) and (b)
from Figure 2, over the graph G from Figure 1.
                              (a) v[3]          (b) v[4]8
                                                    v[6]

    In Gremlin, GPM is performed by traversing9 over a graph G. A
traversal t over G derives paths of arbitrary length. Therefore, a GPM
query in Gremlin can be perceived as a path traversal. Rodriguez et al. [18]
define a path as:

Definition 3 (Path). A path p is a sequence or a string, where p ∈ E ∗
and E ⊂ (V ×Le ×V )10 . A path allows for repeated edges and the length of
a path is denoted by ||p||, which is equal to the number of edges in p. t
                                                                        u
8
   Please note that since we did not explicitly specify any values, the traversal returns
   the ids of the ”matched” elements as a result.
 9
   The act of visiting of vertices (v ∈ V ) and edges (e ∈ E) in a graph in an alternating
   manner (in some algorithmic fashion) [17].
10
   The kleene start operation * constructs the free monoid E∗ = ∞             i          0
                                                                      S
                                                                        n=0 E . where E
   = {�}; � is the identity/empty element.


                                            6
�    Moreover, from [17] we also know that these path queries are com-
prised of several atomic operations called the single-step traversals. A list
of graph-specific operators have been defined in [17,18]. We outline these
and other operators, in the following.

2.3      Graph Algebra Foundations
We present a consolidated summary of various graph query operators
defined in the literature [3,9,13,14,18,17]. For brevity, we abstain from
dwelling into rigorous formal definitions and underlying proofs and refer
the interested reader to the respective articles.

Unary operators

Projection (πa,b,.. ) : R ∪ S → Σ ∗ : operator projects values of a specific
set of variables a, b, .., n (i.e. keys and elements), from the solution of
a matched input graph pattern P , against the graph G. Moreover, the
results returned by (πa,b ) are not deduplicated be default, i.e. the result
will contain as many possible matched values or items as the input pattern
P . This operator is present in all standard graph query languages (e.g.
SELECT in SPARQL, and MATCH in CYPHER).

Selection (∃(p)), is analogous to the filter operator (σ), as defined in [13,1],
restricts the match of a certain graph pattern P against a graph G,
by imposing conditional expressions (p) e.g., inequalities and/or other
traversal-specific predicates (where predicate is a proposition formula).

Binary operators

Concatenation [18] (◦): E ∗ × E ∗ → E ∗ : concatenates two paths (cf.
Definition 3). For instance, if (i, α, j) and (j, β, k) are two edges in a graph
G, then their concatenation is the new path (i, α, j, β, k); where i, j, k ∈ V
and α, β ∈ Le .

Union operator (]): P (E ∗ ) × P (E ∗ ) → P (E ∗ ) : is the multiset union11
(bag union) of two path traversals or graph patterns. For instance, {(1,2),
(3,4), (3,4), (4,5)} ] {(1,2), (3,4)} = {(1,2), (1,2), (3,4), (3,4), (3,4),
(4,5)}. The results of this operator, like projection, are not deduplicated
by default.
11
     Note that the domains and ranges of each of these sets are the power sets.


                                            7
�Join [18] (./◦ ): P (E ∗ ) × P (E ∗ ) → P (E ∗ ) : produces the concatenative
join of two sets of paths (path traversals) such that if P, R ∈ P (E ∗ ), then

     P ./◦ R = {p ◦ r | p ∈ P ∧ r ∈ R ∧ (p = � ∨ r = � ∨ γ + (p) = γ − (r))}12

For instance, if P = {(v1 , e1 , v2 ), (v2 , e2 , v3 )} and R = {(v2 , e2 , v3 ), (v2 , e2 , v1 )},
then,

              P ./◦ R = {(v1 , e1 , v2 , v2 , e2 , v3 ), (v1 , e1 , v2 , v2 , e2 , v1 )},

where v1 , v2 , v3 ∈ V ; e1 , e2 ∈ Le .

Left -join (d|><|), Right-join (|><|d) and the Anti -join (.) operators: these op-
erators, are not explicitly implemented in Gremlin, unlike in other graph
query languages [16]. Their results can, however, be simulated by the
user, at run-time via selecting desired values of elements, vertices or edges
declaring using the projection operator. For instance, an anti-join can be
”computationally” achieved by not’ing an argument in the match step
by using .not() Gremlin step.


General Extensions. We borrow the extended relational operators
Grouping (†a (p)), Sorting (<⇑a,⇓b (p)) and Deduplication (δa,b,.. (p)) which
have been defined in [13]. A detailed illustration with formal definitions
of extended operators can be found in [6].


Graph-specific Extensions. Various graph/traversal-specific operators
have been defined in works such as [9,18]. Furthermore, there also exist
certain application-specific extensions of algebra operators, such as the α
and β operators, for graph data aggregation (used in complex graph net-
work analysis) defined by [7]. We present graph-specific operators, some
of which have been adapted from [9,13] and propose additional operators
based on the algebra defined by [18,17].

 – The Get-vertices/Get-edges nullary operators (Vg / Eg ): return the list
   of vertices/edges, respectively. These operators, w.r.t. Gremlin query
   construct, denote the start of a traversal. It is also possible to traverse
   from a specific vertex/edge in a graph, given their id’s. Furthermore,
   they can be used to construct custom indexes over elements depending
   on user’s choice.
12
     Here, (γ − , γ + ) denote the first and last elements of a path respectively.


                                                  8
�        Ops     Operation      Operator       Gremlin Step     Step type
                Get vertices       Vg            g.V()               -
          0
                 Get edges         Eg            g.E()               -
                  Selection        ∃(p)            .where()      Filter
                                a
               Property filter σcondition  (p) .has()/.values()  Filter
                 Projection     Πa,b,... (p)       .select()      Map
               De-duplication    δa,b,.. (p)       .dedup()      Filter
          1
                 Restriction      λsl (p)          .limit()      Filter
                   Sorting      <⇑a,⇓b (p)      .order().by()     Map
                 Grouping          †a (p)       .group().by() Map/SideEffect
              Traverse (out/in) lv2
                                  v1 [e](p)      .out()/.in()   FlatMap
                   Join          p ./◦ r          .and()          Filter
          2
                  Union           p]r           .union()         Branch
Table 1. A consolidated list of relational algebra graph operators with their corre-
sponding instruction steps in Gremlin traversal language.



 – The Traverse operator (lv2                           ∗
                              v1 [e](p)): P (V ∪ E) × Σ → P (V ∪ E) : is
   an adapted version, analogues to the expand-both operator defined
   by [9]. The traverse operator represents the traversing over the graph
   operation (traversing in ↓ or out ↑ from a vertex (v1 ) to an adjacent
   vertex (v2 ) given the edge label [e], where (v1, v2) ∈ V, e ∈ Le ).
                                     v/e
 – The Property filter operator (σcondition (p)): P (V ∪ E) × S → Σ ∗ : is a
   binary operator which: (i) filters the values of selected element (ver-
   tex/edge), if a condition is declared, (ii) otherwise, it simply returns
   the value of the element’s property.
 – The Restriction unary operator (λsl (p)) is an adaptation of [12], which
   we borrow from [13]. It takes a list as input and returns the top s
   values, skipping specified l values. It is analogous to the LIMIT and
   OFFSET modifier keyword pair in SPARQL.


3      The Gremlin Graph Traversal Language and Machine
Gremlin is the query language of Apache TinkerPop13 graph comput-
ing framework. Gremlin is system agnostic, and enables both – pattern
matching (declarative) and graph traversal (imperative) style of querying
over graphs.

The Machine. Theoretically, a set of traversers in T move (traverse)
over a graph G (property graph, cf. Section 2.1) according to the instruc-
13
     Gremlin: Apache TinkerPop’s graph traversal language and machine (https://
     tinkerpop.apache.org/)


                                          9
�tion in (Ψ ), and this computation is said to have completed when there
are either:
1. no more existing traversers (t), or
2. no more existing instructions (ψ) that are referenced by the traversers
   (i.e. program has halted).
Result of the computation being either a null/empty set (i.e. former case)
or the multiset union of the graph locations (vertices, edges, labels, prop-
erties, etc.) of the halted traversers which they reference. Rodriguez et
al. [16] formally define the operation of a traverser t as follows:
                                       t∈T
                               G← µ           ψ →Ψ                                (1)
                                       {β, ς}
where, µ: T → U is a mapping from the traverser to its location in G;
ψ: T → Ψ maps a traverser to a step in Ψ ; β: T → N maps a traverser
to its bulk14 ; ς: T → U maps a traverser to its sack (local variable of a
traverser) value.

The Traversal. A Gremlin graph traversal can be represented in any
host language that supports function composition and function nesting.
These steps are are either of:
1. Linear motif - f ◦ g ◦ h, where the traversal is a linear chain of steps;
   or
2. Nested motif - f ◦ (g ◦ h) where, the nested traversal g ◦ h is passed
   as an argument to step f [16].
A step (f ∈ Ψ ) can be, defined as f : A? → B ?15 . Where, f maps a set
of traversers of type A (located at objects of A) to a set of traversers
of type B (located at objects of B). Given that Gremlin is a language
and a virtual machine, it is possible to design another traversal language
that compiles to the Gremlin traversal machine (analogous to how Scala
compiles to the JVM). As a result, there exists various Gremlin dialects
such as Gremlin-Groovy, Gremlin-Python, etc.
    A Gremlin traversal (Ψ ) can be compiled down to a collection of steps
or instructions which form the Gremlin instruction set. The Gremlin in-
struction set comprises approximately 30 steps which are sufficient to pro-
vide general purpose computing and for expressing the common motifs of
14
   The bulk of a traverser is number of equivalent traversers a particular traverser
   represents.
15
   The Kleene star notation (A? , B ? ) denotes that multiple traversers can be in the
   same element (A,B).


                                         10
�    any graph traversal query, as highlighted by [16]. However, in a major-
    ity of cases only around 10 of these instructions are sufficient to address
    the most common information needs (i.e. for graph pattern matching and
    traversal).

    3.1      Graph Pattern Matching Queries in Gremlin
    Gremlin provides the GPM construct, analogous to SPARQL [3,14,19]16 ,
    using the Match()-step. This enables the user to represent the query using
    multiple individual connected or disconnected graph patterns. Each of
    these graph patterns can be perceived as a simple path traversal, to-and-
    from a specific source and destination, over the graph.
        Each traversal is a path query starting at a particular source (A)
    and terminating at a destination (B) by visiting vertices (v ∈ V) and
    edges (e ∈ E (V × V) ) in an alternating fashion (i.e. referred to as
    traversing [17]). Each path query is composed of one or more single-step
    traversals. Through function composition and currying , it is possible
    to define a query of arbitrary length [17]. These path queries can be a
    combination of either a source, destination, labelled traversal or all of
    them in a varying fashion, depending on the query defined by the user.
    Example 3. For instance, consider a simple path traversal to the oldest
    person that marko knows over the graph G as show in Figure 1. Listing 1.1
    represents the gremlin query for the described traversal.
1   g .V( ) . has ( ”name” , ”marko” ) . out ( ” knows ” ) . v a l u e s ( ” age ” ) . max ( )
                Listing 1.1. Return the age of the oldest person marko knows

    Here, g.V() i.e. Vg is the traverser definition bijective to V where, ]i µ((Vg )i )
    = V. Functionally, this query be written using function currying as:
                    max(valuesage (outknows (hasname=marko (Vg )))))                             (2)
    The terms outknows , valuesage and hasname are the single-step Grem-
    lin operations/traversals. In [17], Rodriguez presents the itemisation of
    such single-step traversals which can be used to represent a complex path
    traversal. Thus, as described earlier, through functional composition and
    currying one can represent a graph traversal of random length. If i be
    the starting vertex in G, then the traversal shown in listing 1.1 can be
    represented as following function:
                   f (i) = max(�age ◦ vin ◦ eknows          marko
                                             lab+ ◦ eout ◦ �name+ ) (i)                          (3)
    16
         However, Property Graphs do not encode all semantics of RDF Graphs (e.g. blank
         nodes.


                                                   11
�    where, f : P(V) → P(S). A detailed illustration of the single step traversals
    can be referred from [17].

    3.2     Evaluation of match()-step in Gremlin
    The match()-step17 evaluates the input graph patterns over a graph G
    in a structure preserving manner binding the variables and constants to
    their respective values (cf. Definition 2). We denote the evaluation of
    a traversal t over a graph G, using the notation [[t]]g which is borrowed
    from [14,4]. When a match()-step is encountered by the Gremlin machine,
    it treats each graph pattern as an individual path traversal. These graph
    patterns are represented using as()-step18 (step-modulators19 i.e. naming
    variables) such as a, b, c, etc.), which typically mark the start (and end)
    of particular graph patterns or path traversals.
        However, the order of execution of each graph pattern is up to the
    match()-step implementation, where the variables and path labels are
    local only to the current match()-step. Due to this uniqueness of the
    Gremlin match()-step it is possible to:
    1. treat each graph pattern individually as a single step traversal and
       thus, construct composite graph patterns by joining (path-joins) each
       of these single step traversals;
    2. combine multiple match()-steps for constructing complex navigational
       traversals (i.e. multi-hop queries), where each composite graph pattern
       (from a particular match()-step) can be joined using the concatena-
       tive join (ref. Section 2.3).
          For instance, consider the GPM gremlin query as shown in Listing 1.2.
1 g .V( ) . match (
2               . a s ( ’ a ’ ) . out ( ’ c r e a t e d ’ ) . a s ( ’ b ’ ) ,
3               . a s ( ’ b ’ ) . has ( ’ name ’ , ’ l o p ’ ) ,
4               . as ( ’b ’ ) . in ( ’ created ’ ) . as ( ’ c ’ ) ,
5               . a s ( ’ c ’ ) . has ( ’ age ’ , 3 0 ) ) . s e l e c t ( ’ a ’ , ’ c ’ ) . by ( ’ name ’ )
    Listing 1.2. This traversal returns the names of people who created a project named
    ’lop’ that was also created by someone who is 30 years old.

         Each of the comprising four graph patterns (traversals) of the query
    (listing 1.2), can be individually represented using the curried functional
    notation as described in Equation 2. Thus,
    17
       http://tinkerpop.apache.org/docs/3.2.3/reference/#match-step
    18
       Meaningful names can be used as variable names for enhancing query readability.
    19
       Rodriguez et al. [17] refer to step modulators as ‘syntactic sugar’ that reduce the
       complexity of a step’s arguments by modifying the previous step.


                                                      12
�                                                 lop
           f (i) = (ecreated
                     lab+ ) ◦ eout (i); g(i) = (�name+ ◦ vin ) (i);          (4)

             h(i) = (ecreated                    30
                      lab+ ) ◦ ein (i); j(i) = (�age+ ◦ vin ) (i)            (5)
    The input arguments of the match()-step are the set of graph patterns
defined above in equations 4,5, which form a composite graph pattern
(the final traversal (Ψ )). At run-time, when a traverser enters match()-
step, it propagates through each of these patterns guaranteeing that, for
each graph pattern, all the prefix and postfix variables (i.e. ”a”, ”b”,
etc) are binded with their labelled path values. It is only then allowed
to exit, having satisfied this condition. In simple words, though each of
these graph patterns is evaluated individually, it is made sure that at run-
time, the overall structure of the composite graph pattern is preserved by
mapping the path labels to declared variables.
    For instance, in the query (ref. listing 1.2), the starting vertex of g(i)
labelled as ”b” which is the terminal vertex of f (i), similarly for h(i) and
j(i) with vertex labelled as ”c”. It is therefore necessary, to keep a track
of the current location of a traverser in the graph, to preserve traversal
structure. This is achieved in Gremlin by match() and bind() functions
respectively, which we outline next.
    The evaluation of an input graph pattern/traversal in Gremlin is taken
care by two functions:

1. the recursively defined match() function- which evaluates each con-
   stituting graph pattern and keeps a track of the traversers location in
   the graph (i.e. path history), and,
2. the bind() function- which maps the declared variables (elements and
   keys) to their respective values.

Using equations (4, 5) (curried functional form of path traversals) in the
recursive definition of match() by [16], we have:
                  
                  
                   [[bindb (f(t∆a (t) ∧ ∆m1 ))]]g : ∆a 6= φ = ∆m1
                  
                   [[g(t∆b (t) ∧ ∆m2 )]]g         : ∆b 6= φ = ∆m2
                  
                  
         [[t]]g = [[bindc (h(t∆b (t) ∧ ∆m3 ))]]g : ∆b 6= φ = ∆m3       (6)
                   [[j(t∆a (t) ∧ ∆m4 )]]g         : ∆c 6= φ = ∆m4
                  
                  
                  
                  
                  t                               : otherwise,

where, t∆a (t) is the labelled path of traverser t. A path (ref. definition 3) is
labelled ”a” via the step-modulator .as(), of the traverser in the current
traversal (Ψ ); ∆m1 , ∆m2 , ∆m3 are hidden path labels which are appended

                                       13
�Fig. 4. Conceptual architecture for formalizing a Gremlin traversal using graph relation
algebra.



to the traversers labelled path for ensuring that each pattern is executed
only once; and bindx (t) is defined as:
                            
                             t∆x (t) = µ(t)        : ∆x (t) = φ
                 bindx (t) = t                      : ∆x (t) = µ0 (t)               (7)
                              φ                     : otherwise.
                            

where µ0 : T → U, is a function that maps a traverser to its current location
in the graph G (e.g., v ∈ V, V ∈ U) [16]. It (µ0 ) can be perceived analogues
to µ defined in definition 1, which maps elements and keys to values in
G, however in later case the value is the location of a traverser in G.


4     Mapping Gremlin GPM traversals to Graph Algebra

In this section, we present a mapping algorithm for encoding a given
Gremlin pattern-matching traversal, relational graph algebra. Figure 4,
describes the conceptual architecture for formalizing Gremlin traversals.
We follow a bottom-up approach in order to construct the relational graph
algebra based on the traversal.


4.1    Mapping Gremlin traversals to Graph Algebra

1. The input query is parsed and its constituent individual graph pat-
   terns are extracted from the match()-step and the optional where()
   step. /* Parse step
2. For each single graph patterns (single path traversals) in the query,
   we first construct the curried functional form (ref. equation 2).

                                          14
�     3. We then map the get-vertices/get-edges operator for the encountered
        g.V()/g.E() step (i.e. to the first graph pattern) respectively. /* Steps
        2-12 are the Build steps
     4. Append a traverse-operator to all the respective in-coming and out-
        going edge traversals for each, that appear inside the match()-step.
     5. Append a property-filter operator to all the respective has() and
        values() steps based on the match()-step.
     6. Multiple match() steps can be connected processed using the concate-
        native join operator.
     7. Append a selection operator, if the match() step is succeeded by a
        where() step (this is an optional in gremlin queries).
     8. Append a projection operator, if select()-step is declared with a
        match() or where() step.
     9. Append a deduplication operator, based on whether the dedup() step
        is declared after the select() step.
    10. Append a sorting operator, if the order() step with an optional by()
        modifier is declared after the select() step.
    11. Append a grouping operator, if the group() step with an optional
        by() modifier is declared after the select() step.
    12. Map the union operator if the query contains a union()-step20 . Union
        is technically a binary operator, however, a union of multiple patterns
        can be constructed using a left deep join tree representation.

       Next we present three examples of gremlin traversals which have been
    formalised using the proposed graph relational algebra.

    Example Query 1. The sample query as shown in listing 1.2, can be
    formalized as:
             �     �                                                   ��
                       c
       †name Πa,c Jσage=30               b
                           ↓cb [created]σname=lop ↑ba [created](Vg )Kg    (8)
                     |                     {z                     }
                                                                     t

    Example Query 2. Consider the following gremlin traversal shown in list-
    ing 1.3 below:
1   g .V( ) . match (
2             . a s ( ’ a ’ ) . h a s L a b e l ( ’ p e r s o n ’ ) . v a l u e s ( ’ age ’ ) . a s ( ’ b ’ ) ) .
         s e l e c t ( ’ b ’ ) . o r d e r ( ) . by ( a s c )
    Listing 1.3. This traversal returns the list all the persons in the ascending order of
    the age.
    20
         It is not a common practice to use a union()-step in Gremlin GPM traversals, as mul-
         tiple match()-steps in conjunction with where()-steps can be used as per required
         (the ad infinitium style of traversing [16]).


                                                              15
�        The gremlin traversal shown above (Listing 1.3) can be formalized as
    follows:               �                          �
                                            b   a
                                  <⇑b Πb Jσage σlabel=person (Vg )Kg                                           (9)
                                          |          {z         }
                                                               t


    Example Query 3. Consider the following gremlin traversal shown in list-
    ing 1.4 below,
1 g .V( ) . union (
2     . match (     . a s ( ’ a ’ ) . out ( ’ c r e a t e d ’ ) . a s ( ’ c ’ ) ) ,
3     . match (     . a s ( ’ b ’ ) . out ( ’ c r e a t e d ’ ) . a s ( ’ c ’ ) ) ) . s e l e c t ( ’ a ’ , ’ c ’ )
    Listing 1.4. This traversal returns the list of all the people who have collaboratively
    created a software.

        The gremlin traversal shown above (Listing 1.4) can be formalized as
    follows:         �                                       �
                      Πb,c J↑ca [created](Vg )Kg ] J↑cb [created](Vg )Kg                                     (10)
                            |                   {z                  }
                                                       t = t1 ] t2


    Optimizations. The Gremlin graph traversal machine inherently offers a
    wide variety of machine and query level optimizations as traversal strate-
    gies including (i) query rewriting (decoration), (ii) traversal optimization,
    (iii) vendor optimization (using byte-code for gremlin language variants),
    (iv) finalization, and (v) verification. We will not go into the specific de-
    tails, rather we point the interested reader to (Section 4, page 6-7 of [16]).



    Limitations. We do not cover the complete Gremlin language, as clarified
    earlier, we strictly focus on formalizing the GPM (declarative) construct.
    In the declarative construct of Gremlin, in this work, we only focus on
    covering the core functionality of pattern-based graph traversing. We do
    not formalize mutating and specific graph-based task (such as, central-
    ity, eccentricity, etc) traversals and data manipulation operators, e.g.,
    addVertex(), addEdge(), addProperty(), aggregate() operators.


    5    Related Work

    This section summarizes work towards formalizing query algebras for dif-
    ferent data models and corresponding query languages.

                                                         16
�Property graphs. The Property Graph data model is one of the popu-
lar graph data models that provides a rich set of features for the user
to model domain-specific real world data. Various query languages have
been proposed over the years for querying over PGs. The Cypher query
language21 , native to the Neo4J PG database, is a high-level declarative
pattern matching-based graph query language. The developers of Neo4J
& Cypher strive at standardizing Cypher by providing open formal spec-
ification via the OpenCypher22 project [20]. One of the limitations of
Cypher is that it misses certain graph querying functionality such as the
support for regular path queries and graph construction. PGQL [27], is
an SQL-like syntax based graph query language for the PG data model.
Albeit being able to overcome the limitations of Cypher, and lure the SQL
community with its SQL-like syntax support, PGQL lacks standardiza-
tion and support by database technology vendors.

RDF: The Resource Description Framework (RDF), is another graph
data model, popular in the semantic web domain. In RDF the data (i.e.,
entity descriptions) are stored as triples, similar to the node-edge formal-
ism in PGs. SPARQL [15], the query language for RDF triple stores, is a
Cypher-like declarative GPM query language for querying RDF graphs.
SPARQL is a W3C standard and its query algebra has been formally
described in works such as [14,4]. Moreover, multiset semantics have also
been formalized by [3,19].

SQL: Relational databases cater rather limited support for executing
graph queries. However, certain databases such as PostgreSQL allow the
execution of recursive queries. The SAP HANA Graph Scale-Out Ex-
tension prototype (GSE), using a SQL-type language proposed by [11],
supports modelling high level graph queries.


6     Conclusion and Outlook

In this extended paper, we presented the initial efforts on formalizing
GPM traversals, which is a subset of the Gremlin traversal language
and machine. Since, Gremlin is both a query language and a machine,
it enables the graph (pattern-match) traversals to be represented in any
formal query language, given that it supports function composition and
nesting. Our current work provides a theoretical foundation to leverage
21
     https://neo4j.com/developer/cypher-query-language/
22
     http://www.opencypher.org/


                                      17
�this advantage of Gremlin for querying graphs on various graph engines.
Furthermore, our current work lays the foundation for supporting query
interoperability by allowing translation of SPARQL queries to Gremlin
GPM traversals [23,24], using the proposed mapping, in order to: (i) lever-
age the advantage of using graph traversal for query property graphs, and
(ii) enable the use of SPARQL query language (the defacto standard of
RDF stores) on top of other OLAP-based graph processors and OLTP-
based graph engines [23,24]. This enables the semantic web community
to reap best of both worlds, i.e., accessing a plethora of graph data man-
agement systems without the obligation of embracing a new graph query
language. As the near future work, we aim to address the limitations
pointed out in Section 4.1.


Acknowledgement


          This work is supported by the funding received from EU-H2020 Frame-
          work Programme under grant agreement No. 780732 (BOOST4.0)




References
1. R. Angles, M. Arenas, et al. Foundations of modern graph query languages. arXiv
   preprint arXiv:1610.06264, 2016.
2. R. Angles, P. Boncz, J. Larriba-Pey, I. Fundulaki, T. Neumann, O. Erling,
   P. Neubauer, N. Martinez-Bazan, V. Kotsev, and I. Toma. The linked data bench-
   mark council: a graph and rdf industry benchmarking effort. ACM SIGMOD
   Record, 43(1):27–31, 2014.
3. R. Angles et al. The multiset semantics of SPARQL patterns. In The Semantic
   Web - ISWC -15th International Semantic Web Conference, Kobe, Japan, pages
   20–36, 2016.
4. R. Angles and C. Gutierrez. The expressive power of sparql. In International
   Semantic Web Conference, pages 114–129. Springer, 2008.
5. R. Angles, H. Thakkar, and D. Tomaszuk. RDF and property graphs interoperabil-
   ity: Status and issues. In Proceedings of the 13th Alberto Mendelzon International
   Workshop on Foundations of Data Management, Asunción, Paraguay, June 3-7,
   2019., 2019.
6. H. Garcia-Molina, J. D. Ullman, et al. Database systems: the complete book. Pear-
   son Education India, 2009.
7. L. Gomes-Jr, B. Amann, et al. Beta-algebra: Towards a relational algebra for
   graph analysis, 2015.
8. A. Gubichev and M. Then. Graph pattern matching: Do we have to reinvent the
   wheel? In Proceedings of Workshop on GRAph Data management Experiences and
   Systems, pages 1–7. ACM, 2014.


                                        18
� 9. J. Hölsch and M. Grossniklaus. An algebra and equivalences to transform graph
    patterns in neo4j. In EDBT/ICDT 2016 Workshops: EDBT Workshop on Query-
    ing Graph Structured Data (GraphQ), 2016.
10. Y. Keswani, H. Thakkar, M. Dubey, J. Lehmann, and S. Auer. The litmus test:
    Benchmarking rdf and graph data management systems. In Proceedings of 13th
    International Conference on Semantic Systems-Poster & Demos, 2017.
11. C. Krause et al. An sql-based query language and engine for graph pattern
    matching. In International Conference on Graph Transformation, pages 153–169.
    Springer, 2016.
12. C. Li, K. C.-C. Chang, et al. Ranksql: query algebra and optimization for relational
    top-k queries. In Proceedings of the 2005 ACM SIGMOD international conference
    on Management of data, pages 131–142. ACM, 2005.
13. G. S. J. Marton. Formalizing opencypher graph queries in relational algebra.
    Published online on FTSRG archive, 2017.
14. J. Pérez, M. Arenas, et al. Semantics and complexity of sparql. In International
    semantic web conference, pages 30–43. Springer, 2006.
15. E. Prud et al. Sparql query language for rdf. Citeulike Online Archive, 2006.
16. M. A. Rodriguez. The gremlin graph traversal machine and language (invited
    talk). In Proceedings of the 15th Symposium on Database Programming Languages,
    Pittsburgh, PA, USA, pages 1–10, 2015.
17. M. A. Rodriguez and P. Neubauer. The graph traversal pattern. In Graph Data
    Management: Techniques and Applications., pages 29–46. IGI Global, 2011.
18. M. A. Rodriguez and P. Neubauer. A path algebra for multi-relational graphs. In
    Workshops Proceedings of the 27th International Conference on Data Engineering,
    ICDE 2011, pages 128–131, 2011.
19. M. Schmidt, M. Meier, et al. Foundations of sparql query optimization. In Proceed-
    ings of the 13th International Conference on Database Theory, pages 4–33. ACM,
    2010.
20. G. Szárnyas et al. opencypher specification. Online FTSRG archive, 2017.
21. H. Thakkar. Towards an open extensible framework for empirical benchmarking
    of data management solutions: LITMUS. In European Semantic Web Conference,
    pages 256–266. Springer, 2017.
22. H. Thakkar, Y. Keswani, M. Dubey, et al. Trying not to die benchmarking: Orches-
    trating RDF and graph data management solution benchmarks using LITMUS. In
    Proceedings of the 13th International Conference on Semantic Systems, SEMAN-
    TICS 2017, Amsterdam, The Netherlands, September 11-14, 2017, 2017.
23. H. Thakkar, D. Punjani, et al. A stitch in time saves nine–SPARQL querying of
    property graphs using gremlin traversals. arXiv:1801.02911, 2018.
24. H. Thakkar, D. Punjani, J. Lehmann, and S. Auer. Two for one: Querying property
    graph databases using SPARQL via gremlinator. In Proc. of the 1st ACM SIGMOD
    Joint International Workshop on Graph Data Management Experiences & Systems
    (GRADES) and Network Data Analytics (NDA), pages 1–5. ACM, 2018.
25. H. Thakkar, D. Punjani, M.-E. Vidal, and S. Auer. Towards an integrated graph
    algebra for graph pattern matching with gremlin. In Proceedings of the 28th Inter-
    national Conference, DEXA 2017, Lyon, France, August 28-31, 2017, Proceedings,
    Part I, pages 81–91. Springer, 2017.
26. C. Unger, A. N. Ngomo, et al. 6th open challenge on question answering over linked
    data (QALD-6). In Semantic Web Challenges - Third SemWebEval Challenge at
    ESWC 2016, Heraklion, Crete, Greece, pages 171–177, 2016.


                                          19
�27. O. van Rest, S. Hong, et al. Pgql: a property graph query language. In Proceedings
    of the Fourth International Workshop on Graph Data Management Experiences
    and Systems, page 7. ACM, 2016.




                                         20
�
</pre>