10/27/2020 Graph database - Wikipedia

Graph database
In computing, a graph database (GDB) is a database that uses graph structures for semantic
queries with nodes, edges, and properties to represent and store data.[1] A key concept of the system
is the graph (or edge or relationship). The graph relates the data items in the store to a collection of
nodes and edges, the edges representing the relationships between the nodes. The relationships allow
data in the store to be linked together directly and, in many cases, retrieved with one operation.
Graph databases hold the relationships between data as a priority. Querying relationships is fast
because they are perpetually stored in the database. Relationships can be intuitively visualized using
graph databases, making them useful for heavily inter-connected data.[2]

Graph databases are a type of NoSQL database, created to address the limitations of relational
databases. While the graph model explicitly lays out the dependencies between nodes of data, the
relational model and other NoSQL database models link the data by implicit connections. In other
words, relationships are a first-class citizen in a graph database and can be labelled, directed, and
given properties. This is compared to relational approaches where these relationships are implied and
must be reified at run-time. Graph databases are similar to 1970s network model databases in that
both represent general graphs, but network-model databases operate at a lower level of abstraction[3]
and lack easy traversal over a chain of edges.[4]

The underlying storage mechanism of graph databases can vary. Some depend on a relational engine
and “store” the graph data in a table (although a table is a logical element, therefore this approach
imposes another level of abstraction between the graph database, the graph database management
system and the physical devices where the data is actually stored). Others use a key-value store or
document-oriented database for storage, making them inherently NoSQL structures.

Retrieving data from a graph database requires a query language other than SQL, which was designed
for the manipulation of data in a relational system and therefore cannot "elegantly" handle traversing
a graph. As of 2017, no universal graph query language has been adopted in the same way as SQL was
for relational databases, and there are a wide variety of systems, most often tightly tied to one
product. Some standardization efforts have occurred, leading to multi-vendor query languages like
Gremlin, SPARQL, and Cypher. In addition to having query language interfaces, some graph
databases are accessed through application programming interfaces (APIs).

Graph databases differ from graph compute engines. Graph databases are technologies that are
translations of the relational online transaction processing (OLTP) databases. On the other hand,
graph compute engines are used in online analytical processing (OLAP) for bulk analysis. Graph
databases attracted considerable attention in the 2000s, due to the successes of major technology
corporations in using proprietary graph databases,[5] along with the introduction of open-source
graph databases.

Contents
History
Background
Graph models
Labeled-property graph
Resource Description Framework (RDF)
Properties
https://en.wikipedia.org/wiki/Graph_database 1/15
10/27/2020 Graph database - Wikipedia

Storage
Index-free adjacency
Graph types
Comparison with relational databases
Examples
List of graph databases
Graph query-programming languages
See also
References

History
In the mid-1960s, navigational databases such as IBM's IMS supported tree-like structures in its
hierarchical model, but the strict tree structure could be circumvented with virtual records.[6][7]

Graph structures could be represented in network model databases from the late 1960s. CODASYL,
which had defined COBOL in 1959, defined the Network Database Language in 1969.

Labeled graphs could be represented in graph databases from the mid-1980s, such as the Logical
Data Model.[3][8]

Several improvements to graph databases appeared in the early 1990s, accelerating in the late 1990s
with endeavors to index web pages.

In the mid-to-late 2000s, commercial graph databases with ACID guarantees such as Neo4j and
Oracle Spatial and Graph became available.

In the 2010s, commercial ACID graph databases that could be scaled horizontally became available.
Further, SAP HANA brought in-memory and columnar technologies to graph databases.[9] Also in
the 2010s, multi-model databases that supported graph models (and other models such as relational
database or document-oriented database) became available, such as OrientDB, ArangoDB, and
MarkLogic (starting with its 7.0 version). During this time, graph databases of various types have
become especially popular with social network analysis with the advent of social media companies.

Background
Graph databases portray the data as it is viewed
conceptually. This is accomplished by transferring
the data into nodes and its relationships into edges.

A graph database is a database that is based on

graph theory. It consists of a set of objects, which
can be a node or an edge.

Nodes represent entities or instances such as

people, businesses, accounts, or any other item
to be tracked. They are roughly the equivalent of
a record, relation, or row in a relational database,
or a document in a document-store database. Graph databases employ nodes, properties, and
Edges, also termed graphs or relationships, are edges.
the lines that connect nodes to other nodes;
https://en.wikipedia.org/wiki/Graph_database 2/15
10/27/2020 Graph database - Wikipedia

representing the relationship between them. Meaningful patterns emerge when examining the
connections and interconnections of nodes, properties and edges. The edges can either be
directed or undirected. In an undirected graph, an edge connecting two nodes has a single
meaning. In a directed graph, the edges connecting two different nodes have different meanings,
depending on their direction. Edges are the key concept in graph databases, representing an
abstraction that is not directly implemented in a relational model or a document-store model.
Properties are information associated to nodes. For example, if Wikipedia were one of the
nodes, it might be tied to properties such as website, reference material, or words that starts with
the letter w, depending on which aspects of Wikipedia are germane to a given database.

Graph models

Labeled-property graph

A labeled-property graph model is represented by a set of nodes, relationships, properties, and labels.
Both nodes of data and their relationships are named and can store properties represented by
key/value pairs. Nodes can be labelled to be grouped. The edges representing the relationships have
two qualities: they always have a start node and an end node, and are directed;[10] making the graph a
directed graph. Relationships can also have properties. This is useful in providing additional
metadata and semantics to relationships of the nodes.[11] Direct storage of relationships allows a
constant-time traversal.[12]

Resource Description Framework (RDF)

In an RDF graph model,

the addition of
information is each
represented with a
separate node. For
example, imagine a
scenario where a user has
to add a name property for
a person represented as a
distinct node in the graph.
In a labeled-property An example RDF graph
graph model, this would
be done with an addition
of a name property into the node of the person. However, in an RDF, the user has to add a separate
node called hasName connecting it to the original person node. Specifically, an RDF graph model is
composed of nodes and arcs. An RDF graph notation or a statement is represented by: a node for the
subject, a node for the object, and an arc for the predicate. A node may be left blank, a literal and/or
be identified by a URI. An arc may also be identified by a URI. A literal for a node may be of two
types: plain (untyped) and typed. A plain literal has a lexical form and optionally a language tag. A
typed literal is made up of a string with a URI that identifies a particular datatype. A blank node may
be used to accurately illustrate the state of the data when the data does not have a URI.[13]

It is used in Facebook's Open Graph protocol to "allow any web page to have the same functionality as
any other object on Facebook"[14] and the Semantic Web.

Properties

https://en.wikipedia.org/wiki/Graph_database 3/15
10/27/2020 Graph database - Wikipedia

Graph databases are a powerful tool for graph-like queries. For example, computing the shortest path
between two nodes in the graph. Other graph-like queries can be performed over a graph database in
a natural way (for example graph's diameter computations or community detection).

Graphs are flexible, meaning it allows the user to insert new data into the existing graph without loss
of application functionality. There is no need for the designer of the database to plan out extensive
details of the database's future use cases.

Storage

The underlying storage mechanism of graph databases can vary. Some depend on a relational engine
and “store” the graph data in a table (although a table is a logical element, therefore this approach
imposes another level of abstraction between the graph database, the graph database management
system and the physical devices where the data is actually stored). Others use a key-value store or
document-oriented database for storage, making them inherently NoSQL structures. A node would
be represented as any other document store, but edges that link two different nodes hold special
attributes inside its document; a _from and _to attributes.

Index-free adjacency

Data lookup performance is dependent on the access speed from one particular node to another.
Because index-free adjacency enforces the nodes to have direct physical RAM addresses and
physically point to other adjacent nodes, it results in a fast retrieval. A native graph system with
index-free adjacency does not have to move through any other type of data structures to find links
between the nodes. Directly related nodes in a graph are stored in the cache once one of the nodes are
retrieved, making the data lookup even faster than the first time a user fetches a node. However, such
advantage comes at a cost. index-free adjacency sacrifices the efficiency of queries that do not use
graph traversals. Native graph databases use index-free adjacency to process CRUD operations on the
stored data.

Graph types

There are multiple types of graphs that can be categorized. Gartner suggests the five broad categories
of graphs:[15]

Social graph: this is about the connections between people; examples include Facebook, Twitter,
and the idea of six degrees of separation
Intent graph: this deals with reasoning and motivation.
Consumption graph: also known as the "payment graph", the consumption graph is heavily used
in the retail industry. E-commerce companies such as Amazon, eBay and Walmart use
consumption graphs to track the consumption of individual customers.
Interest graph: this maps a person's interests and is often complemented by a social graph. It has
the potential to follow the previous revolution of web organization by mapping the web by interest
rather than indexing webpages.
Mobile graph: this is built from mobile data. Mobile data in the future may include data from the
web, applications, digital wallets, GPS, and Internet of Things (IoT) devices.

Comparison with relational databases

https://en.wikipedia.org/wiki/Graph_database 4/15
10/27/2020 Graph database - Wikipedia

Since Edgar F. Codd's 1970 paper on the relational model,[16] relational databases have been the de
facto industry standard for large-scale data storage systems. However, relational models require a
strict schema and data normalization imposed limitations on how relationships can be queried.

Traditionally, databases have been designed with the relational model, where data is normalized to
support ACID transactions. The data normalization process removes any duplicate data within the
database. The goal of data normalization is to preserve data consistency. The relational model
enforces ACID transactions, separating data into many tables.

Relational models enforce heavy data normalization in order to guarantee consistency. One of the
relational model's design motivations was to achieve a fast row-by-row access.[16] Problems arise with
when there is a need to form complex relationships between the stored data. Although relationships
can be analyzed with the relational model, complex queries performing many join operations on
many different attributes over several tables are required. In working with relational models, foreign
key constraints should also be considered when retrieving relationships, causing additional overhead.

Compared with relational databases, graph databases are often faster for associative data sets and
map more directly to the structure of object-oriented applications. They can scale more naturally to
large datasets as they do not typically need join operations, which can often be expensive. As they
depend less on a rigid schema, they are marketed as more suitable to manage ad hoc and changing
data with evolving schemas.

Conversely, relational database management systems are typically faster at performing the same
operation on large numbers of data elements, permitting the manipulation of the data in its natural
structure. Despite the graph databases' advantages and recent popularity over the relational
databases, it is recommended the graph model itself should not be the sole reason to replace an
existing relational database. A graph database may become relevant if there is an evidence for
performance improvement by orders of magnitude and lower latency.[17]

Examples

The relational model gathers data together using information in the data. For example, one might
look for all the "users" whose phone number contains the area code "311". This would be done by
searching selected datastores, or tables, looking in the selected phone number fields for the string
"311". This can be a time-consuming process in large tables, so relational databases offer indexes,
which allow data to be stored in a smaller sub-table, containing only the selected data and a unique
key (or primary key) of the record. If the phone numbers are indexed, the same search would occur in
the smaller index table, gathering the keys of matching records, and then looking in the main data
table for the records with those keys. Usually, a table is stored in a way that allows a lookup via a key
to be very fast.[18]

Relational databases do not inherently contain the idea of fixed relationships between records.
Instead, related data is linked to each other by storing one record's unique key in another record's
data. For example, a table containing email addresses for users might hold a data item called userpk,
which contains the primary key of the user record it is associated with. In order to link users and their
email addresses, the system first looks up the selected user records primary keys, looks for those keys
in the userpk column in the email table (or, more likely, an index of them), extracts the email data,
and then links the user and email records to make composite records containing all the selected data.
This operation, termed a join, can be computationally expensive. Depending on the complexity of the
query, the number of joins, and indexing various keys, the system may have to search through
multiple tables and indexes and then sort it all to match it together.[18]

https://en.wikipedia.org/wiki/Graph_database 5/15
10/27/2020 Graph database - Wikipedia

In contrast, graph databases directly store the relationships between records. Instead of an email
address being found by looking up its user's key in the userpk column, the user record contains a
pointer that directly refers to the email address record. That is, having selected a user, the pointer can
be followed directly to the email records, there is no need to search the email table to find the
matching records. This can eliminate the costly join operations. For example, if one searches for all of
the email addresses for users in area code "311", the engine would first perform a conventional search
to find the users in "311", but then retrieve the email addresses by following the links found in those
records. A relational database would first find all the users in "311", extract a list of the primary keys,
perform another search for any records in the email table with those primary keys, and link the
matching records together. For these types of common operations, graph databases would
theoretically be faster.[18]

The true value of the graph approach becomes evident when one performs searches that are more
than one level deep. For example, consider a search for users who have "subscribers" (a table linking
users to other users) in the "311" area code. In this case a relational database has to first search for all
the users with an area code in "311", then search the subscribers table for any of those users, and then
finally search the users table to retrieve the matching users. In contrast, a graph database would
search for all the users in "311", then follow the backlinks through the subscriber relationship to find
the subscriber users. This avoids several searches, look-ups, and the memory usage involved in
holding all of the temporary data from multiple records needed to construct the output. In terms of
big O notation, this query would be time – i.e., proportional to the logarithm of the
size of the data. In contrast, the relational version would be multiple lookups, plus the time
needed to join all of the data records. [18]

The relative advantage of graph retrieval grows with the complexity of a query. For example, one
might want to know "that movie about submarines with the actor who was in that movie with that
other actor that played the lead in Gone With the Wind". This first requires the system to find the
actors in Gone With the Wind, find all the movies they were in, find all the actors in all of those
movies who were not the lead in Gone With the Wind, and then find all of the movies they were in,
finally filtering that list to those with descriptions containing "submarine". In a relational database,
this would require several separate searches through the movies and actors tables, doing another
search on submarine movies, finding all the actors in those movies, and then comparing the (large)
collected results. In contrast, the graph database would walk from Gone With the Wind to Clark
Gable, gather the links to the movies he has been in, gather the links out of those movies to other
actors, and then follow the links out of those actors back to the list of movies. The resulting list of
movies can then be searched for "submarine". All of this can be done via one search.[19]

Properties add another layer of abstraction to this structure that also improves many common
queries. Properties are essentially labels that can be applied to any record, or in some cases, edges as
well. For example, one might label Clark Gable as "actor", which would then allow the system to
quickly find all the records that are actors, as opposed to director or camera operator. If labels on
edges are allowed, one could also label the relationship between Gone With the Wind and Clark Gable
as "lead", and by performing a search on people that are "lead" "actor" in the movie Gone With the
Wind, the database would produce Vivien Leigh, Olivia de Havilland and Clark Gable. The equivalent
SQL query would have to rely on added data in the table linking people and movies, adding more
complexity to the query syntax. These sorts of labels may improve search performance under certain
circumstances, but are generally more useful in providing added semantic data for end users.[19]

Relational databases are very well suited to flat data layouts, where relationships between data is one
or two levels deep. For example, an accounting database might need to look up all the line items for
all the invoices for a given customer, a three-join query. Graph databases are aimed at datasets that
contain many more links. They are especially well suited to social networking systems, where the
"friends" relationship is essentially unbounded. These properties make graph databases naturally

https://en.wikipedia.org/wiki/Graph_database 6/15
10/27/2020 Graph database - Wikipedia

suited to types of searches that are increasingly common in online systems, and in big data
environments. For this reason, graph databases are becoming very popular for large online systems
like Facebook, Google, Twitter, and similar systems with deep links between records.

To further illustrate, imagine a relational model with two tables: a people table (which has a
person_id and person_name column) and a friend table (with friend_id and person_id, which is
a foreign key from the people table). In this case, searching for all of Jack's friends would result in
the following SQL query.

SELECT p2.person_name
FROM people p1
JOIN friend ON (p1.person_id = friend.person_id)
JOIN people p2 ON (p2.person_id = friend.friend_id)
WHERE p1.person_name = 'Jack';

The same query may be translated into --

Cypher, a graph database query language

MATCH (p1:person)-[:FRIEND-WITH]-(p2:person)
WHERE p1.name = "Jack"
RETURN p2.name

SPARQL, an RDF graph database query language standardized by W3C and used in multiple
RDF Triple and Quad stores
Long form

PREFIX foaf: <http://xmlns.com/foaf/0.1/>

SELECT ?name
WHERE { ?s a foaf:Person .
?s foaf:name "Jack" .
?s foaf:knows ?o .
?o foaf:name ?name .
}

Short form

PREFIX foaf: <http://xmlns.com/foaf/0.1/>

SELECT ?name
WHERE { ?s foaf:name "Jack" ;
foaf:knows ?o .
?o foaf:name ?name .
}

SPASQL, a hybrid database query language, that extends SQL with SPARQL

SELECT people.name
FROM (
SPARQL PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?name
WHERE { ?s foaf:name "Jack" ;
foaf:knows ?o .
?o foaf:name ?name .
}
) AS people ;

https://en.wikipedia.org/wiki/Graph_database 7/15
10/27/2020 Graph database - Wikipedia

The above examples are a simple illustration of a basic relationship query. They condense the idea of
relational models' query complexity that increases with the total amount of data. In comparison, a
graph database query is easily able to sort through the relationship graph to present the results.

There are also results that indicate simple, condensed, and declarative queries of the graph databases
do not necessarily provide good performance in comparison to the relational databases. While graph
databases offer an intuitive representation of data, relational databases offer better results when set
operations are needed.[12]

List of graph databases

The following is a list of notable graph databases:

https://en.wikipedia.org/wiki/Graph_database 8/15
10/27/2020 Graph database - Wikipedia

Name Version License Language Description

Proprietary,
clients: Resource Description
7.0.0 (April C#, C, Common Lisp,
AllegroGraph Eclipse Framework (RDF) and graph
2020) Java, Python
Public database
License v1
Amazon Neptune is a fully
managed graph database by
Amazon.com. It is used as a
web service and is part of
1.0.1.0.200237.0 Amazon Web Services.
Amazon Neptune (September Proprietary Not disclosed Supports popular graph
2018)[20] models property graph and
W3C's RDF, and their
respective query languages
Apache TinkerPop Gremlin
and SPARQL.
AnzoGraph DB is a massively
parallel native graph GOLAP
(Graph Online Analytics
Processing) style database
built to support SPARQL and
Cypher Query Language to
analyze trillions of
AnzoGraph DB 2.1 (Feb 2020) Proprietary C, C++
relationships. AnzoGraph DB
is designed for interactive
analysis of large sets of
semantic triple data, but also
supports labeled properties
under proposed W3C
standards.[21][22][23][24]
NoSQL native multi-model
database system developed
by ArangoDB Inc. The
C++, JavaScript, .NET, database system supports
Free Apache
3.7.2 / (August Java, Python, Node.js, three important data models
ArangoDB 2,
21, 2020) PHP, Scala, Go, Ruby, (key/value, documents,
Proprietary,
Elixir graphs) with one database
core and a unified query
language called AQL
(ArangoDB Query Language)
Distributed, real-time, scalable
DataStax v6.0.1 (June database; supports Tinkerpop
Proprietary Java
Enterprise Graph 2018) and integrates with
Cassandra[25]

https://en.wikipedia.org/wiki/Graph_database 9/15
10/27/2020 Graph database - Wikipedia

Name Version License Language Description

Grakn is an open-source,
distributed knowledge graph
for knowledge-oriented
systems. It is an evolution of
the relational database for
highly interconnected data as
it provides a concept-level
schema that fully implements
the Entity-Relationship (ER)
model. However, Grakn’s
schema is a type system that
implements the principles of
Free, GNU knowledge representation and
Grakn Core 1.8.2 Java
AGPLv3 reasoning. This enables
Grakn's declarative query
language, Graql (Grakn’s
reasoning and analytics query
language), to provide a more
expressive modelling
language and the ability to
perform logical reasoning over
large amounts of complex
data. Effectively, Grakn is a
knowledge base for artificial
intelligence and cognitive
computing systems.
3.0 (January Proprietary,
InfiniteGraph Java Distributed and cloud-enabled
2013) commercial
Open source, scalable,
distributed across a multi-
machine cluster graph
database under The Linux
Foundation; supports various
storage backends (Apache
Cassandra, Apache HBase,
Google Cloud Bigtable, Oracle
BerkeleyDB);[27] supports
0.5.2 (May 3, global graph data analytics,
JanusGraph Apache 2 Java
2020)[26] reporting, and ETL through
integration with big data
platforms (Apache Spark,
Apache Giraph, Apache
Hadoop); supports geo,
numeric range, and full-text
search via external index
storages (Elasticsearch,
Apache Solr, Apache
Lucene).[28]
Multi-model NoSQL database
Proprietary,
that stores documents (JSON
freeware
MarkLogic 8.0.4 (2015) Java and XML) and semantic graph
developer
data (RDF triples); also has a
version
built-in search engine
Offers graph database abilities
to model many-to-many
relationships. The graph
Microsoft SQL relationships are integrated
RC1 Proprietary SQL/T-SQL, R, Python
Server 2017 into Transact-SQL and use
SQL Server as the
foundational database
management system.[29]

https://en.wikipedia.org/wiki/Graph_database 10/15
10/27/2020 Graph database - Wikipedia

Name Version License Language Description

Open-source, supports ACID,
has high-availability clustering
GPLv3
for enterprise deployments,
Community Java, .NET, JavaScript,
and comes with a web-based
Edition, Python, Go,
administration that includes full
commercial
4.1.2 transaction support and visual
& AGPLv3 Ruby, PHP, R,
Neo4j (September node-link graph explorer;
options for
2020)[30] enterprise Erlang/Elixir, C/C++, accessible from most
Clojure, Perl, Haskell programming languages using
and
its built-in REST web API
advanced
interface, and a proprietary
editions
Bolt protocol with official
drivers.
Multi-model (Hybrid) relational
database management system
(RDBMS) that supports both
SQL and SPARQL for
declarative (Data Definition
and Data Manipulation)
operations on data modeled
as SQL tables and/or RDF
Graphs. Also supports
Open
indexing of RDF-Turtle, RDF-
Source
N-Triples, RDF-XML, JSON-
Edition is
LD, and mapping and
OpenLink Virtuoso 8.2 (Oct 2018) GPLv2, C, C++
generation of relations (SQL
Enterprise
tables or RDF graphs) from
Edition is
numerous document types
proprietary
including CSV, XML, and
JSON. May be deployed as a
local or embedded instance
(as used in the NEPOMUK
Semantic Desktop), a one-
instance network server, or a
shared-nothing elastic-cluster
multiple-instance networked
server[31]
Property Graph and RDF
Graph capabilities as features
in multi-model Oracle
Database:

1. Property Graph -
consisting of a set of
objects or vertices, and a
set of arrows or edges
connecting the objects.
Vertices and edges can
Oracle Spatial and have multiple properties,
Graph; part of 12.1.0.2 (2014) Proprietary Java, PL/SQL which are represented as
Oracle Database key-value pairs. Includes
PGQL, a SQL-like graph
query language and an in-
memory analytic engine
(PGX) with 50+ prebuilt
parallel graph algorithms
2. RDF Semantic Graph:
comprehensive W3C RDF
graph management in
Oracle Database with
native reasoning and triple-
level label security.

https://en.wikipedia.org/wiki/Graph_database 11/15
10/27/2020 Graph database - Wikipedia

Name Version License Language Description

Second-generation distributed
graph database with the
flexibility of documents in one
product (i.e., it is both a graph
database and a document
NoSQL database); licensed
Community
under open-source Apache 2
Edition is
license; and has full ACID
3.0.28 (Feb Apache 2,
OrientDB Java support; it has a multi-master
2020) Enterprise
replication and sharding;
Edition is
supports schema-less, -full,
commercial
and -mixed modes; has
security profiling based on
user and roles; supports a
query language similar to SQL.
It has HTTP REST and JSON
API.
In-memory, queryable Property
Redis Graph database which uses
2.0.20 (Sep Source sparse matrices to represent
RedisGraph C
2020) Available the adjacency matrix in graphs
License and linear algebra to query the
graph.[32]
2.0 SPS 05 C, C++, Java, JavaScript In-memory ACID transaction
SAP HANA Proprietary
(June 2020)[33] & SQL-like language supported property graph[34]
High-performance scalable
database management system
Proprietary, from Sparsity Technologies;
commercial, main trait is its query
freeware for performance for retrieving and
Sparksee 5.2.0 (2015) C++
evaluation, exploring large networks; has
research, bindings for Java, C++, C#,
development Python, and Objective-C;
version 5 is the first graph
mobile database
Distributed, real-time graph
2.0 (February database featuring cell-level
Sqrrl Enterprise Proprietary Java
2015) security and mass-
scalability[35]
MPP database incorporating
patented engines supporting
native SQL, MapReduce and
Java, SQL, Python, C++,
Teradata Aster 7 (2016) Proprietary graph data storage and
R
manipulation; provides a set of
analytic function libraries and
data visualization[36]
Model driven graph database
TerminusDB 2.0.5 (2020) GPLv3 Prolog, Rust, JSON-LD designed for knowledge graph
representation

Graph query-programming languages

AQL (ArangoDB Query Language): a SQL-like query language used in ArangoDB for both
documents and graphs
Cypher Query Language (Cypher): a graph query declarative language for Neo4j that enables ad
hoc and programmatic (SQL-like) access to the graph.[37]
GraphQL: an open-source data query and manipulation language for APIs

https://en.wikipedia.org/wiki/Graph_database 12/15
10/27/2020 Graph database - Wikipedia

Gremlin: a graph programming language that is a part of Apache TinkerPop open-source

project[38]
SPARQL: a query language for RDF databases that can retrieve and manipulate data stored in
RDF format

See also
Graph transformation
Hierarchical database model
Object database
RDF Database
Structured storage
Text graph

References
1. Nikolaos G. Bourbakis (1998). Artificial Intelligence and Automation (https://books.google.com/bo
oks?id=mV3wxKLHlnwC&q=%22gdb%22+%22graph+database%22&pg=PA381). World
Scientific. p. 381. ISBN 9789810226374. Retrieved 2018-04-20.
2. Yoon, Byoung-Ha; Kim, Seon-Kyu; Kim, Seon-Young (March 2017). "Use of Graph Database for
the Integration of Heterogeneous Biological Data" (https://www.ncbi.nlm.nih.gov/pmc/articles/PM
C5389944). Genomics & Informatics. 15 (1): 19–27. doi:10.5808/GI.2017.15.1.19 (https://doi.org/
10.5808%2FGI.2017.15.1.19). ISSN 1598-866X (https://www.worldcat.org/issn/1598-866X).
PMC 5389944 (https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5389944). PMID 28416946 (http
s://pubmed.ncbi.nlm.nih.gov/28416946).
3. Angles, Renzo; Gutierrez, Claudio (1 Feb 2008). "Survey of graph database models" (https://web.
archive.org/web/20170815064527/https://www.cse.iitk.ac.in/users/smitr/PhD%20Resources/Surv
ey%20of%20Graph%20Databases%20Models.pdf) (PDF). ACM Computing Surveys. 40 (1): 1–
39. CiteSeerX 10.1.1.110.1072 (https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.110.10
72). doi:10.1145/1322432.1322433 (https://doi.org/10.1145%2F1322432.1322433).
S2CID 207166126 (https://api.semanticscholar.org/CorpusID:207166126). Archived from the
original (http://www.cse.iitk.ac.in/users/smitr/PhD%20Resources/Survey%20of%20Graph%20Dat
abases%20Models.pdf) (PDF) on 15 August 2017. Retrieved 28 May 2016. "network models [...]
lack a good abstraction level: it is difficult to separate the db-model from the actual
implementation"
4. Silberschatz, Avi (28 January 2010). Database System Concepts, Sixth Edition (http://codex.cs.y
ale.edu/avi/db-book/db6/appendices-dir/d.pdf) (PDF). McGraw-Hill. p. D-29. ISBN 978-0-07-
352332-3.
5. "Graph Databases Burst into the Mainstream" (https://www.kdnuggets.com/2018/02/graph-databa
ses-burst-into-the-mainstream.html). www.kdnuggets.com. Retrieved 2018-10-23.
6. Silberschatz, Avi (28 January 2010). Database System Concepts, Sixth Edition (http://codex.cs.y
ale.edu/avi/db-book/db6/appendices-dir/e.pdf) (PDF). McGraw-Hill. p. E-20. ISBN 978-0-07-
352332-3.
7. Parker, Lorraine. "IMS Notes" (http://www.people.vcu.edu/~lparker/IMS.html). vcu.edu. Retrieved
31 May 2016.
8. Kuper, Gabriel M. (1985). The Logical Data Model: A New Approach to Database Logic (http://ww
w.dtic.mil/dtic/tr/fulltext/u2/a323935.pdf) (PDF) (Ph.D.). Docket STAN-CS-85-1069. Retrieved
31 May 2016.
9. "SAP Announces New Capabilities in the Cloud with HANA" (http://www.dbta.com/Editorial/News-
Flashes/SAP-Announces-New-Capabilities-in-the-Cloud-with-HANA-100186.aspx). 2014-10-22.
Retrieved 2016-07-07.

https://en.wikipedia.org/wiki/Graph_database 13/15
10/27/2020 Graph database - Wikipedia

10. Frisendal, Thomas (2017-09-22). "Property Graphs" (http://www.dataversity.net/property-graphs-s

wiss-army-knife-data-modeling/). graphdatamodeling.com. Retrieved 2018-10-23.
11. Das, S; Srinivasan, J; Perry, Matthew; Chong, Eugene; Banerjee, Jay (2014-03-24). "A Tale of
Two Graphs: Property Graphs as RDF in Oracle" (https://www.researchgate.net/publication/26470
2160).
12. Have, Christian Theil; Jensen, Lars Juhl (2013-10-17). "Are graph databases ready for
bioinformatics?" (https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3842757). Bioinformatics. 29
(24): 3107–3108. doi:10.1093/bioinformatics/btt549 (https://doi.org/10.1093%2Fbioinformatics%2
Fbtt549). ISSN 1460-2059 (https://www.worldcat.org/issn/1460-2059). PMC 3842757 (https://ww
w.ncbi.nlm.nih.gov/pmc/articles/PMC3842757). PMID 24135261 (https://pubmed.ncbi.nlm.nih.go
v/24135261).
13. "Resource Description Framework (RDF): Concepts and Abstract Syntax" (https://www.w3.org/T
R/rdf-concepts/#section-Overview). www.w3.org. Retrieved 2018-10-24.
14. "Open Graph protocol" (http://ogp.me/). ogp.me. Retrieved 2018-10-23.
15. "The Competitive Dynamics of the Consumer Web: Five Graphs Deliver a Sustainable
Advantage" (https://www.gartner.com/doc/2081316/competitive-dynamics-consumer-web-
graphs). www.gartner.com. Retrieved 2018-10-23.
16. Codd, E. F. (1970-06-01). "A relational model of data for large shared data banks".
Communications of the ACM. 13 (6): 377–387. doi:10.1145/362384.362685 (https://doi.org/10.11
45%2F362384.362685). ISSN 0001-0782 (https://www.worldcat.org/issn/0001-0782).
S2CID 207549016 (https://api.semanticscholar.org/CorpusID:207549016).
17. "Graph Databases, 2nd Edition" (https://www.safaribooksonline.com/library/view/graph-databases
-2nd/9781491930885/). O’Reilly | Safari. Retrieved 2018-10-23.
18. "From Relational to Graph Databases" (http://neo4j.com/developer/graph-db-vs-rdbms/#_from_rel
ational_to_graph_databases). Neo4j.
19. "Examples where Graph databases shine: Neo4j edition" (https://zeroturnaround.com/rebellabs/e
xamples-where-graph-databases-shine-neo4j-edition/2/), ZeroTurnaround
20. "Amazon Neptune Engine Updates 2018-09-06" (https://docs.aws.amazon.com/neptune/latest/us
erguide/engine-releases-1.0.1.0.200237.0.html). AWS. Retrieved Sep 22, 2018.
21. "In-Memory Massively Parallel Distributed Graph Database Purpose-built for Analytics" (https://w
ww.cambridgesemantics.com/product/anzograph/). www.Cambridgesemantics.com. Retrieved
2018-02-20.
22. Rueter, John (February 15, 2018). "Cambridge Semantics Announces AnzoGraph Graph-Based
Analytics Support for Amazon Neptune and Graph Databases" (https://www.businesswire.com/ne
ws/home/20180215006023/en). Businesswire. Retrieved February 20, 2018.
23. Zane, Barry (November 2, 2016). "Semantic Graph Databases: A worthy successor to relational
databases" (http://www.dbta.com/BigDataQuarterly/Articles/Semantic-Graph-Databases-A-worthy
-successor-to-relational-databases-114569.aspx). www.dbta.com. Retrieved February 20, 2018.
24. "Cambridge Semantics Announces AnzoGraph Support for Amazon Neptune and Graph
Databases" (http://www.dbta.com/Editorial/News-Flashes/Cambridge-Semantics-Announces-Anz
oGraph-Support-for-Amazon-Neptune-and-Graph-Databases-123280.aspx). Database Trends
and Applications. 2018-02-15. Retrieved 2018-03-08.
25. Woodie, Alex (June 21, 2016). "Beyond Titan: The Evolution of DataStax's New Graph Database"
(https://www.datanami.com/2016/06/21/beyond-titan-evolution-datastaxs-new-graph-database/).
Datanami. Retrieved May 9, 2017.
26. "JanusGraph version 0.5.2" (https://github.com/JanusGraph/janusgraph/releases/tag/v0.5.2). May
3, 2020 – via Github.
27. "JanusGraph storage backends" (https://web.archive.org/web/20181002020052/https://docs.janu
sgraph.org/latest/storage-backends.html). Archived from the original (https://docs.janusgraph.org/
latest/storage-backends.html) on 2018-10-02. Retrieved 2018-10-01.
28. "JanusGraph index storages" (https://web.archive.org/web/20181002064503/https://docs.janusgr
aph.org/latest/index-backends.html). Archived from the original (https://docs.janusgraph.org/lates
t/index-backends.html) on 2018-10-02. Retrieved 2018-10-01.

https://en.wikipedia.org/wiki/Graph_database 14/15
10/27/2020 Graph database - Wikipedia

29. "What's New in SQL Server 2017" (https://docs.microsoft.com/en-us/sql/sql-server/what-s-new-in-

sql-server-2017). Microsoft Docs. April 19, 2017. Retrieved May 9, 2017.
30. "Release Notes: Neo4j 4.1.2" (https://neo4j.com/release-notes/neo4j-4-1-2/). Neo4j Graph
Database Platform. Retrieved 2020-09-22.
31. "Clustering Deployment Architecture Diagrams for Virtuoso" (http://virtuoso.openlinksw.com/datas
pace/dav/wiki/Main/VirtClusteringDiagrams). Virtuoso Open-Source Wiki. OpenLink Software.
Retrieved May 9, 2017.
32. Ewbank, Key. "RedisGraph Reaches General Availability" (https://www.i-programmer.info/news/1
97-data-mining/12337-redisgraph-reaches-general-availability.html). i-programmer.info.
33. "What's New in SAP HANA 2.0 SPS 05" (https://blogs.sap.com/2020/06/26/whats-new-in-sap-han
a-2.0-sps-05-2/). Product Information. Retrieved 2020-06-26.
34. Rudolf, Michael; Paradies, Marcus; Bornhövd, Christof; Lehner, Wolfgang. The Graph Story of the
SAP HANA Database (http://cs.emis.de/LNI/Proceedings/Proceedings214/403.pdf) (PDF).
Lecture Notes in Informatics (http://cs.emis.de/LNI/Proceedings/Proceedings214.html).
35. Vanian, Jonathan (18 February 2015). "NSA-linked Sqrrl eyes cyber security and lands $7M in
funding" (https://gigaom.com/2015/02/18/nsa-linked-sqrrl-eyes-cyber-security-and-lands-7m-in-fu
nding/). Gigaom. Retrieved May 9, 2017.
36. Woodie, Alex (October 23, 2015). "The Art of Analytics, Or What the Green-Haired People Can
Teach Us" (https://www.datanami.com/2015/10/23/the-art-of-analytics-or-what-the-green-haired-p
eople-can-teach-us). Datanami. Retrieved May 9, 2017.
37. Svensson, Johan (5 July 2016). "Guest View: Relational vs. graph databases: Which to use and
when?" (http://sdtimes.com/guest-view-relational-vs-graph-databases-use/). San Diego Times.
BZ Media. Retrieved 30 August 2016.
38. TinkerPop, Apache. "Apache TinkerPop" (https://tinkerpop.apache.org/gremlin.html). Apache
TinkerPop. Retrieved 2016-11-02.

Retrieved from "https://en.wikipedia.org/w/index.php?title=Graph_database&oldid=985414485"

This page was last edited on 25 October 2020, at 20:33 (UTC).

Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using this
site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia
Foundation, Inc., a non-profit organization.

https://en.wikipedia.org/wiki/Graph_database 15/15