Explore graph data structures with Elixir, including native vs. external databases, querying with Cypher, Gremlin, and SPARQL, and transforming data between graph models for efficient data management.

elixir.tar.gz

Graph Struct

Graph Commons Library

Testing and Umbrella App

Hello World Graph

Graph Struct-copy

Neo4j connection

neo4j database setup

neo4j database setup-more on bolt

RDF Api Demo

Gremlin

neo4j database setup - API Demo

Custom git pull - Neo4j

Custom git pull -RDF

DGraph_with database

propertyandrdf

neo4j database

RDF Graph

Custom git pull -RDF-copy

DGraph-copy

DGraph_with database-copy

Nobel Prizes

Graph Struct without warnings

Native Graph without warnings

Native Graph without warnings_IEx

Graphviz

Graphviz_water_molecule

Graphviz_water_molecule_fixed

neo4j database_movies

neo4j database-service_contexts

neo4j database_Querying with Cypher

RDF Graph without warnings_IEx

Set up a graph service_RDF graph

Graph-to-Graph

process_graph

process_graph_simulation

RDF Api Demo-copy

Graph data structures are quite intuitive and highly flexible. They’re used to conduct queries in databases and interconnect entities in data networks. Elixir, with its power of concurrency and data- and graph-aware packages, is the perfect language to explore graph data structures.

In this course, you’ll learn basic graph data structures and build a simple graph model. Next, you’ll build a testbed umbrella application to compare native graph structures with external databases. You’ll also learn to query graph database systems using Elixir packages Cypher and Gremlin with property graphs and SPARQL with RDF graphs. Next, you’ll learn how to transform data from one graph model to another. Finally, you’ll learn why property graphs are especially good at graph traversal problems while RDF graphs shine at integrating different semantic models and can scale up to web proportions.

After this course, you’ll be able to work with distributed graph datasets and manage data at scale.

Exploring Graphs with Elixir

What is the best-known language used by graph databases for directly traversing graphs?

What is the best-known language used by graph databases for directly traversing graphs?

TinkerGraph is the underlying graph framework that is distributed by the Apache project, while TinkerPop is an in-memory reference implementation.

TinkerPop is the underlying graph framework that is distributed by the Apache project, while TinkerGraph is an in-memory reference implementation.

Which statement below is correct?

Consider the following Gremlin query:
```XML
"g.V().hasLabel('Book').out().values('name').dedup()" |> gremlin!
```
**(True or False)** The `.out()` in the query above will traverse outgoing edges from `Book` nodes.

Consider the following Gremlin query:
<pre><code class="language-XML">&quot;g.V().hasLabel('Book').out().values('name').dedup()&quot; |&gt; gremlin!
</code></pre>
(True or False) The <code>.out()</code> in the query above will traverse outgoing edges from <code>Book</code> nodes.

What does the following Gremlin query return?
```XML
"g.V().count()" |> gremlin!
```

What does the following Gremlin query return?
<pre><code class="language-XML">&quot;g.V().count()&quot; |&gt; gremlin!
</code></pre>

Test yourself on the concepts covered in this chapter.

Getting Started

Part I - Graphs Everywhere

Getting Started with the Project

Part II - Getting to Grips with Graphs

Exploring Graph Structures

Navigating Graphs with Neo4j

Querying Neo4j with Cypher

Graphing Globally with RDF

Querying RDF with SPARQL

Traversing Graphs with Gremlin

Delivering Data with Dgraph

Part III - Graph to Graph

Processing the Graph

Wrap Up

Quiz on Traversing Graphs with Gremlin