Exploring the Property Graph Model in Gremlin Query Language

Leave a Comment / Database Languages / By piembsystech

tech.com/gremlin-language/">Gremlin is where the real power begins. As the core structure behind Gremlin’s traversal capabilities, this model lets you represent real-world entities (vertices) and their relationships (edges) with rich, flexible metadata. Whether you’re building social networks, recommendation engines, or knowledge graphs, understanding the property graph model is essential for crafting meaningful, queryable connections. In this hands-on guide, you’ll learn how the property graph model works, how it’s implemented in Gremlin, and how to model data that mirrors real-life relationships. We’ll walk through practical examples, traversal patterns, and best practices to ensure your graph structure is clean, scalable, and intuitive. By the end, you’ll be fully equipped to model and navigate complex connected data using Gremlin like a graph pro.

Introduction to Property Graph Model in Gremlin Query Language

The property graph model is the foundation of modern graph databases, and Gremlin brings it to life with powerful traversal capabilities. In this model, data is represented as vertices (nodes) and edges (relationships), each carrying properties as key-value pairs. This allows for rich, flexible, and highly connected data structures. Gremlin, part of the Apache TinkerPop framework, enables you to query and navigate these graphs in an intuitive and expressive way. Whether you’re modeling users, products, devices, or any real-world entity, the property graph model helps you capture complex relationships with ease. In this article, we’ll break down the components of the property graph, explain how Gremlin uses them, and provide hands-on examples. By the end, you’ll have a clear understanding of how to model and query data effectively using the property graph model in Gremlin.

What is the Property Graph Model?

The property graph model is a data modeling structure used in graph databases where:

• Vertices (nodes) represent objects/entities.
• Edges (relationships) connect those objects.
• Properties are key-value pairs stored on both vertices and edges.

Components of the Property Graph Model

This structure allows for storing not just relationships, but also detailed context about both entities and their connections. For example:

Vertex: Person {name: "Alice", age: 30}
Edge: KNOWS {since: "2015"}

This model enables you to answer complex questions such as “Who does Alice know, and since when?” with high performance and semantic accuracy.

Vertices:

Vertices are the primary entities in the graph. In Gremlin, you can create a vertex using addV():

g.addV('person').property('name', 'Alice').property('age', 30)

Each vertex has a label ('person') and a set of properties (name, age). These help identify and describe the entity.

Edges:

Edges are the connections between vertices, created using addE() in Gremlin. They can also have labels and properties:

g.V().has('name', 'Alice').
  addE('knows').
  to(g.V().has('name', 'Bob')).
  property('since', '2015')

This connects Alice to Bob with a ‘knows’ relationship, and the ‘since’ property adds time context.

Properties:

Properties are the key-value pairs attached to both vertices and edges. They provide context and meaning to the graph.

g.addV('product').property('name', 'Laptop').property('price', 1200)

This helps filter and query more efficiently:
g.V().has('product', 'price', gt(1000))

How Gremlin Uses the Property Graph Model

Gremlin is traversal-based, meaning you navigate through the graph step by step using directions and conditions.

Find the people Alice knows:

g.V().has('name', 'Alice').out('knows').values('name')

This traversal:

• Starts at Alice’s vertex
• Follows outgoing 'knows' edges
• Returns the names of connected vertices

Such expressiveness is only possible because of how vertices, edges, and properties work together in the property graph model.

Real-World Example

Let’s say you’re building a movie recommendation system. Here’s how you could model it:

Vertices:

g.addV('person').property('name', 'Emma')
g.addV('movie').property('title', 'Inception')

Edges:

g.V().has('name', 'Emma').
  addE('watched').
  to(g.V().has('title', 'Inception')).
  property('rating', 5)

You can now query:

g.V().has('name', 'Emma').out('watched').has('rating', 5).values('title')

This returns movies Emma watched and rated 5 stars made possible by the property graph structure.

Creating Vertices with Properties

Represent a person named Alice with properties like age and location.

g.addV('person')
 .property('name', 'Alice')
 .property('age', 30)
 .property('city', 'New York')

This code creates a vertex labeled person and adds three properties: name, age, and city. The vertex now represents an entity (Alice) enriched with contextual information. In a property graph, these attributes are attached directly to the node, making it easy to filter or traverse based on any property.

Creating an Edge with Properties

Show that Alice knows Bob and add metadata about their relationship.

g.V().has('name', 'Alice')
 .addE('knows')
 .to(g.V().has('name', 'Bob'))
 .property('since', 2015)

This traversal finds Alice and Bob in the graph, then connects them with a knows edge. The edge has a since property, indicating when the relationship started. In the property graph model, edges are first-class citizens that can store data, enabling rich context in relationships (like timestamps, trust levels, or interaction types).

Why do we need the Property Graph Model in Gremlin Query Language?

The property graph model provides a flexible way to represent entities and their relationships using vertices, edges, and properties. Gremlin leverages this model to enable powerful, real-time graph traversals for complex, connected data.

1. Real-World Relationship Representation

The property graph model allows you to represent real-world entities and their relationships in a natural, visual, and logical way. Instead of forcing relationships into rigid table joins like in relational databases, you model them directly with edges. Each vertex (entity) and edge (relationship) can store properties, providing context. This mirrors how people and systems are connected in reality. It’s especially useful for domains like social media, finance, healthcare, and recommendation engines.

2. Powerful and Expressive Queries

Gremlin leverages the property graph model to perform powerful graph traversals, moving seamlessly from one vertex to another using edges. This model allows querying deep, complex relationships without writing lengthy or nested queries. Properties on both vertices and edges make filtering and condition-based traversal easier. Developers can answer questions like “Find all users who liked the same product as Alice” in a few steps. This expressiveness is hard to achieve in flat relational systems.

3. Rich Data Context with Properties

Unlike simple node-edge models, property graphs support key-value pairs on both nodes and relationships. This gives developers the ability to store metadata directly where it’s most relevant on the entity or the connection. For instance, storing a “since” date on a FRIENDS_WITH edge or a “rating” on a REVIEWED edge makes analysis easier. Gremlin’s syntax makes accessing and filtering by these properties extremely intuitive.

4. Schema Flexibility and Evolution

The property graph model allows for schema-less or schema-light designs, making it easy to evolve your graph structure over time. You can add new properties or vertex types without complex migrations. This is ideal for agile development, prototyping, and handling semi-structured data. Gremlin and TinkerPop do not require rigid schemas, so developers can model data organically based on business needs. It ensures scalability without sacrificing adaptability.

5. Optimized for Traversal Performance

Graphs built using the property graph model are optimized for traversals, which are the backbone of Gremlin. Instead of using joins like in SQL databases, Gremlin follows direct references between vertices and edges. This makes lookups and traversals fast even with millions of connections. Indexing, graph partitioning, and caching work more effectively due to this structure. It ensures real-time performance for use cases like fraud detection or recommendation engines.

6. Enables Graph-Based Use Cases

The property graph model enables a wide range of graph-specific applications. Whether you’re tracking supply chain flows, mapping cybersecurity networks, or modeling knowledge graphs vertices and edges make it all possible. Gremlin allows you to query these models using traversal steps that feel like describing real-world logic. This capability is central to AI, machine learning, and dynamic decision systems, where understanding relationships is key.

7. Supports Deep Relationship Exploration

The property graph model allows for multi-hop traversals, enabling deep exploration of indirect relationships. In Gremlin, you can easily traverse several levels to answer questions like “Who are the friends of friends of Alice?” or “What products are liked by users similar to me?” This is critical for use cases like fraud detection, influence analysis, and social network scoring. Traditional relational models struggle with such depth and performance. The model’s recursive nature is a perfect match for Gremlin’s step-by-step traversal logic.

8. Ideal for Heterogeneous Data Modeling

In real-world scenarios, entities are rarely uniform people, products, events, and locations all differ in shape and properties. The property graph model in Gremlin easily handles this heterogeneity by allowing different vertex and edge types, each with unique properties. You can connect diverse data without restructuring or flattening it. For example, a user can “buy” a product and also “review” it, each with different edge labels and properties. This flexibility supports complex, evolving business models with ease.

Example of a Property Graph Model in Gremlin Query Language

The property graph model in Gremlin allows you to represent real-world entities and their relationships using vertices, edges, and properties. Below is a practical example that demonstrates how to model and query connected data effectively using Gremlin syntax.

1. Social Network – People and Friendships

Model people as vertices and their friendships as edges.

// Create users
g.addV('person').property('name', 'Alice').property('age', 30)
g.addV('person').property('name', 'Bob').property('age', 28)
g.addV('person').property('name', 'Charlie').property('age', 35)

// Create friendships
g.V().has('name', 'Alice').addE('knows').to(g.V().has('name', 'Bob')).property('since', 2016)
g.V().has('name', 'Alice').addE('knows').to(g.V().has('name', 'Charlie')).property('since', 2019)

Each person is a vertex with properties like name and age. Friendships are represented as knows edges with a since property to indicate the year the friendship started. This graph can now answer queries like:

g.V().has('name', 'Alice').out('knows').values('name')

2. E-commerce – Customers and Product Reviews

A customer reviews multiple products with ratings and comments.

// Create customer and products
g.addV('customer').property('name', 'Emma')
g.addV('product').property('title', 'Wireless Mouse').property('price', 1200)
g.addV('product').property('title', 'Mechanical Keyboard').property('price', 3000)

// Create reviews with properties
g.V().has('name', 'Emma').addE('reviewed').to(g.V().has('title', 'Wireless Mouse'))
 .property('rating', 4.5).property('comment', 'Great product').property('date', '2024-09-15')

g.V().has('name', 'Emma').addE('reviewed').to(g.V().has('title', 'Mechanical Keyboard'))
 .property('rating', 5).property('comment', 'Excellent build').property('date', '2024-09-17')

Vertices represent a customer and products. The reviewed edges carry detailed metadata such as rating, comment, and date. This allows complex queries like:

g.V().hasLabel('customer').has('name', 'Emma').outE('reviewed').values('rating')

3. Academic Network – Authors and Publications

Model authors and the papers they’ve written.

// Add authors
g.addV('author').property('name', 'Dr. Smith')
g.addV('author').property('name', 'Dr. Rao')

// Add papers
g.addV('paper').property('title', 'Graph Algorithms 101').property('year', 2020)
g.addV('paper').property('title', 'Advanced Gremlin Techniques').property('year', 2023)

// Add relationships
g.V().has('name', 'Dr. Smith').addE('wrote').to(g.V().has('title', 'Graph Algorithms 101'))
g.V().has('name', 'Dr. Rao').addE('wrote').to(g.V().has('title', 'Advanced Gremlin Techniques'))

This graph stores authors and the papers they’ve written using the wrote edge. Each vertex carries properties (year, title, etc.) for advanced filtering and data mining. Example query:

g.V().hasLabel('author').out('wrote').values('title')

4. IT Infrastructure – Devices and Connections

Represent networked devices and the connections between them.

// Add devices
g.addV('device').property('name', 'Router A').property('ip', '192.168.1.1')
g.addV('device').property('name', 'Switch B').property('ip', '192.168.1.2')
g.addV('device').property('name', 'Server C').property('ip', '192.168.1.3')

// Add network connections
g.V().has('name', 'Router A').addE('connected_to').to(g.V().has('name', 'Switch B')).property('bandwidth', '1Gbps')
g.V().has('name', 'Switch B').addE('connected_to').to(g.V().has('name', 'Server C')).property('bandwidth', '10Gbps')

Each device is a vertex with properties like name and ip. Edges represent network connections and store data such as bandwidth. This graph is useful for network visualization and troubleshooting. Example query:

g.V().has('device', 'name', 'Router A').out('connected_to').values('name')

Advantages of Using the Property Graph Model in Gremlin Query Language

These are the Advantages of Using the Property Graph Model in Gremlin Query Language:

1. Natural Representation of Real-World Relationships: The property graph model allows you to map real-world entities and their relationships naturally. Vertices represent entities like users, devices, or products, while edges represent how they relate like “knows,” “bought,” or “connected_to.” This structure makes it intuitive to visualize and query complex connections. Developers can model systems closer to how people think. The result is more readable data and easier-to-maintain models. Gremlin brings this to life through expressive traversal steps.
2. Rich Metadata on Vertices and Edges: Unlike traditional models, both vertices and edges in the property graph model can store key-value pairs. This allows for enhanced semantic understanding like adding a “since” property on a friendship or “rating” on a product review. You’re not limited to IDs or foreign keys for context. Instead, the graph stores the “what,” “how,” and “why” of relationships. This is invaluable for filtering, ranking, or grouping based on relationship context. Gremlin makes accessing this data easy through simple traversals.
3. High Flexibility and Schema Evolution: The property graph model supports schema-less or schema-light structures, meaning you can evolve the graph without breaking existing data. Need to add a new property or vertex type? Just do it no migrations required. This makes it ideal for agile teams or rapidly changing domains. You can prototype fast and adjust later based on business needs. Gremlin handles these dynamic data models with ease, providing strong flexibility with no extra overhead.
4. Efficient Deep Traversals: In relational databases, traversing multiple tables with joins can be slow and inefficient. In contrast, Gremlin and the property graph model allow deep, recursive traversals like “friends of friends” or “devices two hops away” with minimal latency. Each vertex maintains direct pointers to connected edges and vertices. This dramatically reduces query complexity and improves performance. As your graph grows, Gremlin’s traversal engine remains optimized for high-speed exploration.
5. Better Query Readability and Maintainability: Gremlin’s traversal language, built on the property graph model, is highly readable and modular. You can construct queries in a fluent, chainable format like g.V().has('name', 'Alice').out('knows').values('name'). This is easier to understand than complex nested SQL queries. As your graph logic evolves, so do your traversals cleanly and intuitively. This leads to better maintainability for developers, especially in large-scale or collaborative projects.
6. Ideal for Complex and Heterogeneous Data: The property graph model excels when handling diverse data types that don’t fit neatly into tabular rows. Whether you’re modeling people, events, places, or products, each can have its own label and unique properties. The graph can reflect many-to-many relationships with rich attributes. You avoid data flattening or duplication, which often happens in relational schemas. Gremlin’s support for mixed data types enables powerful cross-entity traversals without extra joins or complexity.
7. Enhances Analytical and Recommendation Use Cases: Graphs are perfect for scenarios like fraud detection, recommendation engines, and network analysis. The property graph model makes it easy to capture interactions and behaviors that can fuel intelligent decisions. For example, you can find users who watched similar movies, detect shortest paths, or calculate influence scores. Gremlin offers traversal steps to run these analytics efficiently across your graph. The model supports both real-time querying and advanced algorithms.
8. Broad Compatibility with Graph Platforms: The property graph model is supported by many Gremlin-compatible databases like JanusGraph, Amazon Neptune, Azure Cosmos DB, and TigerGraph. This ensures flexibility in backend choice and easier migration between systems. Once you master Gremlin and the property graph model, you’re equipped to work with multiple enterprise-grade platforms. This cross-compatibility helps future-proof your graph solutions and reduces vendor lock-in.
9. Enables Context-Aware Decision Making: The property graph model allows you to embed context directly into relationships through edge properties. This enables systems to make smarter decisions based on the nature, strength, or timeline of connections such as prioritizing recommendations by recency or frequency. For instance, a follows edge with a weight or frequency property can determine user engagement strength. Gremlin can traverse and filter based on these properties seamlessly. This contextual awareness improves personalization, relevance, and overall system intelligence.
10. Supports Real-Time Querying at Scale: With direct edge connections and minimal need for joins, the property graph model provides low-latency query performance, even at scale. Whether you’re querying thousands or millions of vertices and edges, Gremlin’s traversal engine efficiently navigates relationships in real time. This is ideal for dynamic applications like fraud detection, recommendation systems, or knowledge graphs where instant responses are crucial. The model supports scalable indexing, parallel execution, and real-time streaming traversal all essential for modern graph applications.

Disadvantages of Using the Property Graph Model in Gremlin Query Language

These are the Disadvantages of Using the Property Graph Model in Gremlin Query Language:

1. Steep Learning Curve for Beginners: New developers often find Gremlin’s traversal-based syntax and the property graph model conceptually challenging. Unlike SQL, which is widely taught and used, Gremlin requires learning a different way of thinking—based on navigating relationships. Understanding how to structure vertices, edges, and properties efficiently takes practice. Mistakes in modeling or traversal steps can lead to poor performance or incorrect results. This learning curve can delay development and increase onboarding time for teams unfamiliar with graph paradigms.
2. Lack of Standardized Query Language: Unlike relational databases that use SQL, there’s no universal standard for graph queries. Gremlin is part of Apache TinkerPop, but other graph databases use Cypher (Neo4j) or GSQL (TigerGraph). This fragmentation can cause compatibility issues when switching databases. Developers may need to learn multiple syntaxes depending on the platform. The lack of standardization can also hinder collaboration across teams or projects using different tools. It creates a steeper barrier to entry for those adopting graph technologies.
3. Performance Challenges on Large-Scale Traversals: While property graphs are efficient for many queries, deep or broad traversals across massive datasets can strain system performance. Without careful indexing and memory management, traversals can become slow or memory-intensive. Some queries may unintentionally traverse the entire graph if not properly scoped. This can lead to latency issues, especially in real-time applications. Gremlin’s performance is highly dependent on graph size, structure, and traversal logic.
4. Complex Query Debugging and Optimization: Debugging a multi-step Gremlin traversal is not as straightforward as debugging SQL. Since Gremlin queries are expressed as chains of traversal steps, it can be hard to pinpoint where things go wrong. There’s also limited tooling for visual query execution plans, making optimization difficult. Developers often need deep knowledge of the graph engine to tune queries. Mistakes like redundant traversals or unnecessary steps can quietly degrade performance. This adds complexity to query development and troubleshooting.
5. Limited Tooling Compared to Relational Ecosystem: The relational database ecosystem has mature tools for administration, visualization, reporting, and performance monitoring. In contrast, Gremlin and property graph-based systems have fewer out-of-the-box GUI tools. While platforms like Amazon Neptune and JanusGraph support Gremlin, their surrounding ecosystems aren’t as full-featured. This can slow down adoption for teams needing dashboards, monitoring, or advanced data analysis tools. Developers may have to build custom tools or integrate third-party solutions.
6. Difficulties in Enforcing Data Constraints: In relational databases, enforcing constraints like uniqueness, foreign keys, or NOT NULL is straightforward. Property graph databases are more flexible but also more lenient often lacking built-in constraint enforcement. This makes it easier to introduce inconsistent or duplicate data if validations aren’t handled manually. Developers must implement their own validation logic either in application code or using traversal checks. Lack of native constraint enforcement can increase data quality risks.
7. Schema Flexibility Can Lead to Inconsistencies: While the schema-less nature of property graphs is an advantage, it can also become a drawback. Without a fixed schema, different vertices of the same label may have different sets of properties. Over time, this can lead to inconsistent or messy data structures. Queries might break if expected properties are missing. Teams must establish strong data modeling guidelines to avoid unintentional complexity or redundancy in graph structure. The lack of enforced consistency can hinder scalability and maintainability.
8. Higher Resource Consumption in Complex Models: Property graph databases can consume more memory and CPU than relational databases, especially when modeling very dense or complex graphs. Each vertex and edge, along with their properties, adds overhead in terms of indexing and storage. In distributed environments, replication and traversal cost can increase. High read/write volumes may require advanced configuration for caching, sharding, or partitioning. Without proper architecture, performance and cost can quickly become issues.
9. Limited Integration with Traditional BI Tools: Most business intelligence (BI) tools are built to work with structured tabular data from relational databases. Integrating property graph data with tools like Power BI, Tableau, or Excel often requires workarounds, data flattening, or intermediate data pipelines. This adds complexity to analytics workflows and may limit the accessibility of graph insights for non-technical stakeholders. As a result, teams might need to invest in custom connectors or develop in-house dashboards. This lack of seamless integration can slow down adoption in enterprise environments.
10. Less Community Support and Learning Resources: Compared to SQL or NoSQL ecosystems, Gremlin and the property graph model still have a relatively smaller community. While resources do exist, the volume of tutorials, courses, Stack Overflow threads, and developer forums is significantly less. This can make troubleshooting harder, especially for niche use cases or advanced optimizations. New developers may find fewer ready-made examples or community plugins to speed up learning. As a result, support may be slower, and the learning curve longer for those just starting out.

Future Development and Enhancement of Using the Property Graph Model in Gremlin Query Language

Following are the Future Development and Enhancement of Using the Property Graph Model in Gremlin Query Language:

1. Native Schema Support and Validation Tools: Future improvements in Gremlin and its graph engines may include more robust native schema enforcement. Currently, the property graph model is mostly schema-less, which increases flexibility but can also cause inconsistencies. Adding built-in schema validation tools would help developers define mandatory properties, labels, and types. This would improve data integrity and reduce application-side validation overhead. As graph databases mature, stronger schema capabilities will be key for enterprise-grade applications.
2. Visual Modeling and Schema Design Interfaces: One major enhancement expected is the development of visual tools to model property graphs easily. These tools would allow users to drag and drop vertex types, define edge relationships, and assign properties visually. Such interfaces will make graph design more accessible to non-developers and analysts. Gremlin support for exporting/importing these models would also improve productivity. These advancements will bridge the gap between technical teams and business users.
3. Improved Performance for Massive-Scale Graphs: Graph platforms are evolving to better handle massive, distributed property graphs. Future developments may focus on smarter indexing, parallel traversals, and hardware acceleration (like GPU-based graph processing). For Gremlin users, this means faster query execution, even on billions of vertices and edges. Enhancements may also include dynamic partitioning for real-time data flow. These optimizations will make Gremlin a stronger choice for big data graph analytics.
4. Standardization Across Graph Query Languages: Currently, graph query languages are fragmented (Gremlin, Cypher, GSQL, etc.). The future may bring standardized graph query models, possibly through open initiatives like GQL (Graph Query Language under ISO). Gremlin may evolve to support or align with such standards, improving interoperability. This will allow easier transitions between different platforms and tools. Standardization will also encourage more tool and ecosystem support across the graph database landscape.
5. Integration with AI and Machine Learning Workflows: Graphs are becoming a critical input for machine learning pipelines. Future enhancements will likely include native support for integrating Gremlin with ML frameworks like TensorFlow, PyTorch, or Neo4j Graph Data Science tools. Property graphs enriched with ML scores or labels can enable real-time decision-making. Gremlin’s traversal language could evolve to handle predictive paths or entity ranking directly. These capabilities will empower developers to build smarter, adaptive systems with Gremlin.
6. Enhanced Support for Time-Based and Temporal Graphs: Property graphs are being adapted for temporal data modeling, where relationships change over time. Future versions of Gremlin may include native support for time-travel queries, versioned edges, and validity intervals. This will be useful for use cases like financial transactions, network security, or social history. Gremlin enhancements will allow developers to write more expressive queries based on time windows or graph evolution. This will unlock new possibilities in dynamic graph analysis.
7. Better Developer Tooling and IDE Extensions: Developer experience will improve with better IDE integration, debugging, and auto-complete features tailored for Gremlin. Tools like VS Code and IntelliJ may offer more plugins for property graph modeling and query testing. This will reduce the barrier to entry for newcomers and increase productivity for experts. Enhanced error messaging, live query previews, and visualization tools are all areas of potential growth. As the ecosystem expands, developer-focused enhancements will be essential.
8. Real-Time Streaming and Event-Driven Graphs: Future enhancements will bring better support for streaming data directly into property graphs. This includes event-driven updates, real-time ingestion, and Gremlin queries that can react to changes as they happen. Platforms like Amazon Neptune and JanusGraph may integrate Kafka-like streaming with Gremlin endpoints. This capability will be vital for use cases like fraud detection, recommendation engines, or IoT. Real-time graph evolution will drive smarter, more responsive systems.
9. Native Support for Graph Analytics and Algorithms: Future versions of Gremlin and graph databases may include built-in graph algorithms like PageRank, community detection, and shortest path. Currently, these are often handled by external tools or require custom traversal logic. Native integration will simplify advanced analytics directly within Gremlin traversals. This empowers developers to combine modeling, querying, and analysis in one system. As demand for graph intelligence grows, these native capabilities will become a core part of Gremlin’s evolution.
10. Expansion of Cloud-Native Graph Services: As more organizations move to the cloud, we’ll see expanded cloud-native support for Gremlin-based graph systems. Services like Amazon Neptune, Azure Cosmos DB, and others will improve scalability, security, and availability of property graph models. Features like serverless graph queries, auto-scaling, and built-in monitoring will become more accessible. This will reduce operational overhead and allow teams to focus on application logic. Gremlin’s future lies in seamless, cloud-first experiences tailored for modern data workloads.

Conclusion

The property graph model lies at the heart of what makes Gremlin powerful, flexible, and expressive for graph data modeling. By understanding how to use vertices, edges, and properties effectively, you unlock the full potential of graph databases. Whether you’re analyzing networks, modeling user behavior, or building intelligent recommendations, mastering this model gives you a strong foundation in the world of connected data.

Further Reference

• https://tinkerpop.apache.org/docs/current
• https://tinkerpop.apache.org/gremlin.html
• https://docs.aws.amazon.com/neptune/latest/userguide/intro.html