Graph databases stand out in the data management landscape with their ability to model and analyze the complex interconnections that mirror the real world, using nodes and edges in place of the rigid structures of tables and rows found in conventional relational databases. However, the essence of leveraging this powerful tool lies in mastering graph query languages, which are essential for effectively navigating and extracting insights from graph databases.

These languages are specifically designed to interact naturally with the graph structure, allowing users to articulate queries that focus on the relationships and connections within the data. This comprehensive guide dives deep into the world of graph query languages, such as Cypher and Gremlin, unlocking their potential and revealing how they fuel the exploration and analysis of complex networks.

We will explore the fundamental concepts behind these languages, highlighting their unique capabilities and how they conform to the graph model. Whether you're an experienced developer or new to graph databases, this guide will arm you with the crucial skills needed to harness the full potential of graph query languages and boost your data management strategies.

What is a graph query language?

A graph query language is a specialized tool designed to interact with graph databases, allowing users to query and manipulate data in a graph-like structure. At its core, it enables direct interaction with nodes and edges, the fundamental components of graph data models. This approach provides a more intuitive way to work with highly connected data compared to traditional relational database queries.

One of the key advantages of graph query languages is their ability to leverage graph-specific operations. For instance, you can easily find the shortest path between two nodes or identify clusters within your data – operations that would be complex and computationally expensive in traditional relational databases. To illustrate, consider a social network scenario: using a graph query language, you could write a concise query to find "friends of friends" or the "most influential person" in a network, tasks that would require multiple joins and complex logic in SQL. 

From a technical perspective, graph query languages fall under the broader category of Data Manipulation Languages (DML) in database management systems. While a complete graph database language typically includes both Data Definition Language (DDL) for defining schema and Data Manipulation Language (DML) for querying and updating data, in this article, we specifically focus on the querying aspect of graph languages. Popular examples like Cypher for Neo4j and Gremlin for Apache TinkerPop-enabled graphs offer a rich set of functions for traversing graphs, pattern matching, and applying graph algorithms. These querying capabilities, with their readable and expressive syntax for graph operations, are our primary interest. We'll explore how these languages excel at querying graph data, setting aside other database operations like creation, deletion, and updates for this discussion.

SQL vs. graph query: A quick comparison

Consider a scenario where you need to find all the friends of friends of a particular person in a social network. In SQL, this would require multiple joins across several tables, potentially leading to complex and slow queries as the network grows.

In contrast, a graph query language is well-suited for handling such relationships. You can express this query concisely, instructing the database to match the pattern two hops away from the starting person and return all connected nodes. This direct navigation of relationships makes graph queries inherently efficient for exploring connections and patterns within the data.

Learn more about the advantages of graph databases.

Example:

Find the friends of a person's friends using their ID.

• SQL (Relational Database):

SELECT f2.name 
FROM friends f1 
JOIN friends f2 ON f1.friend_id = f2.person_id 
WHERE f1.person_id = 123;

• Cypher (Graph Database):

MATCH (p:Person {id:123})-[:FRIEND*2]->(f2:Person) 
RETURN f2.name; 

For more complex queries and larger networks, the benefits of intuitive queries and faster execution become even more apparent compared to SQL.

Check out this blog post for several other use cases of graph databases in social networks.

Fundamentals of graph databases

Before diving deeper into graph query languages, let's solidify our understanding of the foundation upon which they operate: graph databases. These databases are built on a few key concepts that differentiate them from their relational counterparts.

• Nodes and edges: As we've touched upon, nodes are the fundamental entities within a graph, representing people, places, objects, or any data point of interest. Edges, on the other hand, capture the relationships between these nodes, adding context and meaning to the data.
• Properties: Both nodes and edges can have properties associated with them. These properties store additional information about the entities and relationships they represent. For instance, a person node might have properties like name, age, and location, while a friendship edge might have a property like startDate.
• Labels: Nodes and edges can also be assigned labels, categorizing them into different types. This allows for more granular querying and filtering based on specific node or edge types. For example, you might have labels like Person, City, and FRIEND to distinguish different entities and relationships in your graph.

Read my blog post to learn all that you need to know about relationship graphs. 

On top of the actual constructs within the graph, there are also some benefits to using a graph database. These include:

• Schema flexibility: Unlike relational databases with their rigid schemas, graph databases offer greater flexibility. You can add new node and edge types, as well as properties, on the fly without disrupting existing data or queries. This adaptability makes graph databases well-suited for evolving data models and agile development environments. 
• Relationships as first-class citizens: In graph databases, relationships are not just implied connections between tables; they are explicit and integral parts of the data model. This focus on relationships enables powerful traversal and pattern-matching capabilities, unlocking insights that would be challenging to achieve with traditional databases. A social media network is a great example where numerous relationships between users, posts, comments, and more exist.

• Traversal and pathfinding: Graph databases excel at traversing relationships and finding paths between nodes. This makes them ideal for scenarios like social network analysis, recommendation engines, fraud detection, and any application where understanding connections and patterns is crucial. For example, here is the comparison of a three-hop query between SQL and Cypher.

SQL:

Cypher:

By understanding these fundamental concepts, you'll be better equipped to grasp graph query languages and how they work.

How does a graph query language work?

Graph query languages are specialized programming languages designed to interact with graph databases. They provide a way to express complex relationships and patterns within data structures that are organized as graphs. Let's explore the key features and operations of these languages.

Core operations of graph query languages

Pattern matching and traversal

At the core of graph query languages are two fundamental operations: pattern matching and traversal. These operations enable querying graphs in both declarative and imperative ways, respectively, and typically, supporting one of these is sufficient. However, the implementation of pattern matching also relies on traversal.

Pattern matching

Pattern matching allows users to describe specific structures or relationships they want to find within the graph. It's like searching for a particular arrangement of nodes and edges that match certain criteria.

Example (Cypher):

MATCH (person:Person)-[:WORKS_AT]->(company:Company)
WHERE company.name = "PuppyGraph"
RETURN person.name

This query matches all persons who work at a company named "PuppyGraph".

Traversal

Traversal involves moving through the graph structure, following relationships from one node to another. This operation is crucial for exploring connected data and discovering paths between entities.

Example (Gremlin):

g.V().hasLabel('Person').  
	out('FRIENDS_WITH').out('LIVES_IN').has('name', 'New York')

This query starts at all Person nodes, traverses to their friends, then to where those friends live, filtering for those in New York.

Additional operations

Beyond these core operations, graph query languages offer a range of additional functionalities:

Filtering

Filtering allows you to narrow down results based on specific criteria.

Example (SPARQL):

SELECT ?person
WHERE {  
  ?person rdf:type :Person .  
  ?person :age ?age .  
  FILTER (?age > 30)
}

This query selects all persons over 30 years old.

Aggregation

Aggregation functions help in summarizing data across multiple nodes or paths.

Example (Cypher):

MATCH (actor:Person)-[:ACTED_IN]->(movie:Movie)
RETURN actor.name, COUNT(movie) as movieCount
ORDER BY movieCount DESC
LIMIT 5

This query returns the top 5 actors based on the number of movies they've acted in.

The process of a query

Understanding how a graph query is processed can help you write more efficient queries. In general, the process of a graph query is similar to that of its relational counterpart. Here's a simplified overview of the process.

The process begins with query formulation. Users construct their query using the syntax of their chosen graph query language, such as Cypher and Gremlin. They specify patterns and traversals. Users also set filtering conditions and determine the desired output format. 

Once formulated, the query enters the parsing stage. The database engine tokenizes the query string, breaking it into individual components and constructing an abstract syntax tree (AST) that represents the query's logical structure. During this phase, the engine also validates the syntax and semantics of the query, checking for any errors.

Next comes the crucial step of query planning and optimization. The query planner analyzes the AST and generates multiple possible execution plans. It estimates the cost of each plan based on various factors, including available indexes, data distribution statistics, and cardinality estimates. The planner then selects the most efficient execution plan. Optimization techniques might involve reordering operations for early filtering, choosing between index scans and full scans, or deciding on parallel execution strategies.

With an optimized plan in hand, the query moves to the execution phase. The engine follows the plan, typically starting with the most restrictive patterns to reduce the initial result set. This involves node and relationship lookups, graph traversals following specified patterns, and the application of filters and conditions. For large graphs, the engine may employ distributed processing techniques to enhance performance.

As the query executes, the engine must manage intermediate results. It may use in-memory caches for frequently accessed data, and for complex queries, it might persist temporary results to disk to manage memory usage effectively.

If the query involves aggregations or sorting, these operations are performed next. The engine may use specialized algorithms designed for efficient sorting of graph data.

The final step in processing is result retrieval and formatting. The engine assembles the final result set based on the query's SELECT or RETURN clause. Results may include node properties, relationship data, or calculated values and aggregations. The engine formats these results according to the specified output, which could be tabular data, JSON, or a graph structure.

Some graph databases implement an optional query caching step. They may cache query results or execution plans for frequently run queries, allowing subsequent identical queries to bypass some processing steps and improve performance.

Finally, the formatted results are transmitted back to the client application. For large result sets, this may involve streaming data in chunks to manage memory and network load effectively.

Popular graph query languages

Now that we have a good understanding of graph databases and how graph query languages work, let's explore some of the prominent languages in the field. Each language has its own syntax, strengths, and areas of application.

1. Cypher

Cypher is a declarative query language designed specifically for graph databases. Its syntax is inspired by natural language, making it relatively easy to read and understand. Cypher queries typically follow a pattern of MATCH, WHERE, and RETURN, allowing you to express patterns, filter results, and retrieve specific data.

Key features:

• Pattern matching: Cypher excels at pattern matching, allowing you to describe complex graph structures and relationships concisely.
• Declarative nature: You focus on what data you want to retrieve, and Cypher figures out the optimal way to traverse the graph.
• Wide adoption: Cypher is widely used with Neo4j, one of the most popular graph database systems, contributing to its popularity.

Example:

MATCH (p:Person)-[:ACTED_IN]->(m:Movie) 
WHERE m.title = 'The Matrix' 
RETURN p.name;

This query finds all people who acted in the movie "The Matrix."

2. Gremlin

Gremlin is a more imperative and procedural language compared to Cypher. It provides a flexible and powerful way to traverse and manipulate graph data. Gremlin queries are often chained together using steps that filter, transform, and aggregate data as it flows through the traversal.

Key features:

• Traversal framework: Gremlin's core strength lies in its ability to express complex graph traversals and transformations.
• Imperative style: You have fine-grained control over how the graph is traversed and how data is processed at each step.
• Hybrid capability: Gremlin Supports both OLTP and OLAP operations.
• Multilingual integration: Gremlin Can be embedded in multiple programming languages.

Example:

g.V().has('Person', 'name', 'Alice').out('FRIEND').values('name');

This query finds the names of all of Alice's friends.

You can also write the traversal in a more declarative way using match()-step.

g.V().match(  
  as("a").has('Person', 'name', 'Alice'),  
  as("a").out("Friend").as("b")).  
  select("b").values("name")

3. SPARQL

SPARQL (pronounced "sparkle") is a query language primarily used for querying RDF (Resource Description Framework) data, a standard way to represent knowledge graphs. RDF data is essentially a graph where nodes represent resources, and edges represent relationships between them. SPARQL offers powerful capabilities for querying and reasoning over RDF graphs.

Key features:

• RDF compatibility: SPARQL is specifically designed to work with RDF data and its underlying graph structure.
• Semantic web focus: It aligns with the principles of the Semantic Web, enabling querying and inference over linked data.
• SQL-like: SPARQL supports SQL-like syntax for querying graph patterns.

Example:

SELECT ?name
WHERE {  
  ?person foaf:knows ?friend .  
  ?friend foaf:name ?name .
}

This query finds the names of all friends of any person in the graph.

4. GQL

GQL (Graph Query Language) GQL is a new international standard for property graph database languages, officially published as ISO/IEC 39075 in April 2024. Developed by the same committee responsible for SQL, GQL represents a significant milestone as the first new database query language standardized by ISO in over 35 years.

Key features:

• Powerful graph pattern matching (GPM): GQL's GPM allows users to write relatively simple queries for complex data analysis.
• Rich data types: Includes support for various data types, including character and byte strings, fixed-point and floating-point numerics, and native nested data.
• ISO standard: GQL is the official ISO/IEC standard (ISO/IEC 39075) for property graph database languages, providing a standardized approach across the industry.

Example:

MATCH (a {firstname: 'Alice'})-[b]->(c) 
RETURN c

This query finds all nodes with a one-hop relationship to a node with the first name 'Alice'.

Choosing the right language

The choice of graph query language often depends on several factors: the specific graph database system you're using, the nature of your queries, your familiarity with the language's syntax and concepts, and the overall requirements of your project. Cypher's declarative style might be more approachable for beginners and those with SQL experience, as it allows for intuitive pattern matching and readability. Gremlin's imperative approach offers greater flexibility for complex traversals and is well-suited for distributed graph processing. SPARQL is the go-to choice for working with RDF data and knowledge graphs, particularly in semantic web applications. GQL, as the new ISO standard for property graph query languages, may become increasingly dominant in the future, offering a standardized approach that could be particularly valuable for enterprise-level projects and long-term compatibility.

When selecting a graph query language, consider the following:

1. Database compatibility: Ensure the language is supported by your chosen graph database.
2. Query complexity: Evaluate whether you need simple pattern matching or advanced graph traversals.
3. Performance requirements: Some languages may offer better optimization for certain types of queries.
4. Learning curve: Consider your team's expertise and the time available for learning a new language.
5. Community support and ecosystem: A larger community often means better resources and tools.
6. Integration with database language: If a graph query language is part of a broader graph database language supported by your database, it may offer a more seamless and comprehensive development experience.

Ultimately, the right choice will depend on your specific use case and requirements. It's also worth noting that many modern graph databases support multiple query languages, allowing you to leverage the strengths of each as needed.

Challenges and best practices

While graph query languages offer powerful capabilities for navigating and analyzing connected data, they also come with their own set of challenges. Let's explore some common hurdles you might encounter and the best practices to overcome them.

1. Performance optimization

 As your graph database expands in both size and complexity, maintaining efficient query performance may become challengin.. Here are some tips to ensure your queries run efficiently:

• Indexing: Leverage indexing strategically to speed up lookups based on node properties or labels.
• Query profiling: Use profiling tools to identify bottlenecks in your queries and optimize them accordingly.
• Avoid unnecessary traversals: Design queries to minimize unnecessary graph traversals, which can be computationally expensive.
• Limit result sets: Use LIMIT clauses or similar constructs to restrict the number of results returned, especially for large datasets.

2. Expressiveness vs. complexity

Graph query languages can be highly expressive, allowing you to formulate complex traversals and patterns. However, overly complex queries can be difficult to understand and maintain. Strive for a balance between expressiveness and clarity:

• Modularization: Break down complex queries into smaller, reusable components.
• Comments and documentation: Add comments and documentation to explain the purpose and logic of your queries.
• Code reviews: Collaborate with other developers to review and refine your queries.
• Use named patterns: Leverage named patterns or subqueries to improve readability and reusability of complex query parts.

3. Query optimization and execution plans

Understanding how the query engine interprets and executes your queries is crucial for writing efficient code:

• Execution plan analysis: Learn to read and interpret query execution plans provided by your graph database system.
• Parameterized queries: Use parameterized queries to allow the query engine to cache and reuse execution plans.
• Avoid cartesian products: Be cautious of unintended cartesian products in your queries, which can lead to performance issues.

4. Data model alignment

Ensuring your queries align well with your graph data model is essential:

• Schema-aware querying: Familiarize yourself with the graph schema and design queries that match the data structure.
• Consistent naming conventions: Adopt clear and consistent naming conventions for nodes, relationships, and properties to make querying more intuitive.
• Model refactoring: Be prepared to refactor your data model if you find that certain types of queries are consistently inefficient.

5. Learning curve and syntax nuances

Graph query languages often have unique syntax and concepts that can be challenging for newcomers. Address this challenge by:

• Practice and training: Invest time in hands-on practice and structured learning resources.
• Community engagement: Participate in online forums and communities to learn from experienced users.
• Version-specific documentation: Always refer to the most up-to-date documentation for your specific graph query language version.

Remember, the journey of mastering graph query languages is continuous. As you gain experience and tackle more complex scenarios, you'll develop your own set of strategies and techniques to navigate the intricacies of graph data.

PuppyGraph: Graph query language support without a graph database

While graph databases provide a dedicated environment for storing and querying graph data, tools like PuppyGraph offer an alternative approach. PuppyGraph allows you to leverage the power of graph query languages like Cypher and Gremlin directly on your existing relational data, without the need for a separate graph database. This can be particularly useful when you want to explore graph-like relationships within your relational data or gradually transition to a graph database architecture.

Key benefits of PuppyGraph:

• Leverage existing data: Apply graph query languages to your relational data without the need for migration. PuppyGraph eliminates the need for a separate graph database. This approach not only reduces costs and latency but also simplifies data management by utilizing your existing data store permissions. 
• Flexibility: Experiment with graph concepts and queries without committing to a full graph database deployment.
• Scalability: With its auto-partitioned, distributed computing architecture, PuppyGraph is designed to handle petabyte-scale datasets. This ensures that as your relationship graph grows, PuppyGraph scales with it, maintaining performance even with vast networks of connections.

The world of graph data is vast and ever-evolving. As you gain experience and explore new use cases, you'll discover innovative ways to leverage graph databases and query languages to unlock the full potential of your connected data. Whether you're building social networks, recommendation engines, fraud detection systems, or any application that relies on understanding relationships, graph technologies offer a powerful and flexible solution. So embrace the graph, navigate its connections, and let your data tell its story.

Conclusion

Graph query languages have emerged as essential tools for harnessing the power of graph databases. By providing intuitive ways to navigate and analyze highly connected data, these languages offer unique advantages over traditional query methods.

We've explored the fundamental concepts of graph databases, the core operations of graph query languages, and popular options like Cypher, Gremlin, SPARQL, and the emerging GQL standard. Each language brings its own strengths to the table, catering to different use cases and preferences.

Interested in trying PuppyGraph? Start with our forever-free Developer Edition, or try our AWS AMI. Want to see a PuppyGraph live demo? Book a call with our engineering team today.