DEV Community: Wendel Fernandes de Lana

Graph Generation Algorithms

Wendel Fernandes de Lana — Fri, 01 Sep 2023 00:20:03 +0000

Introduction

Apache AGE is a popular graph database management system that excels at handling and querying highly connected data, making it an excellent choice for graph-based applications. A graph generation algorithm for Apache AGE can offer several benefits for various applications and use cases. In this article, I'm going to discuss some of these use cases and how this feature is an important advantage in a graph database.

Applications and Advantages

Graph Data Generation: it can create synthetic graph data for testing and benchmarking purposes. This is particularly useful for evaluating the performance of graph queries, optimizing database schema design, and simulating real-world scenarios without relying on actual data.

Machine Learning and Data Analysis: generated graph data can be used for machine learning tasks and data analysis within Apache AGE.

Testing and Evaluation: it proves valuable for assessing the efficiency and effectiveness of functions integrated into Apache AGE. By crafting graphs with predefined attributes, it simplifies the validation of algorithm accuracy and performance.

Privacy and Security: in scenarios where sharing sensitive data directly isn't viable, graph generation algorithms step in to yield cleansed or anonymized graph data while upholding the fundamental graph structure. This proves invaluable for disseminating data for research or collaboration without compromising security and privacy.

Educational and Training Purposes: it can be used as educational aids to facilitates the teaching of graph concepts, algorithms, graph database queries and even fundamental mathematical theorems like the Watts-Strogatz model and the Barbell graph. This approach significantly improves the learning of graph theory within the context of Apache AGE.

Conclusion

Graph generation algorithms can be used in several different situations and for multiple purposes, making them an important feature in graph databases.

Contribute

Apache AGE documentation
Apache AGE repository
Apache AGE website

Introduction to Apache AGE

Wendel Fernandes de Lana — Fri, 18 Aug 2023 18:44:47 +0000

What is Apache AGE?

The Apache AGE is a PostgreSQL extension that provides graph database functionality. Therefore, it encompasses the Postgres functionalities while incorporating Cypher for graph management. This unique combination empowers you with access to advanced graph query modeling within the framework of your relational database infrastructure.

Definitions

Vertex (node)
It serves as a container for storing entity-related data, potentially encompassing multiple properties. Notably, each vertex can accommodate a variety of properties, yet it is restricted to possessing a singular label designation.
Edge (relationship)
An edge links nodes in a graph, defining a distinct relationship or interaction with defining attributes. This is vital for navigating intricate interconnections in the graph data model.
Path
The path represents a sequence of connected edges and nodes. It captures the route or journey between entities, enabling the exploration of relationships and patterns within the graph.

Common Clauses using Cypher

CREATE: used to add new nodes and edges to the graph.
DELETE: is used to remove nodes, edges, or entire paths from the graph.
MATCH: used to retrieve data from the graph database. It allows you to specify patterns of nodes and edges, facilitating the discovery of interconnected entities and relationships.
MERGE: allows you to either create new nodes and edges or match and update existing ones based on specified patterns.
REMOVE: used to remove properties from vertex and edges.
RETURN: specify what data you want to retrieve as a result of your query. It allows you to define the attributes or properties of nodes and edges that you're interested in.
SET: used to update properties of nodes or edges within the graph.
WHERE: filters the results of a query based on specified conditions. It helps you narrow down your search and retrieve only the data that meets specific criteria.

Examples

Create a vertex without label and returns it

SELECT * FROM cypher('graph_name', $$ 
    CREATE (v) 
    RETURN v
$$) AS (vertex agtype);

Returns all vertices

SELECT * FROM cypher('graph_name', $$ 
    MATCH (v) 
    RETURN v
$$) AS (vertex agtype);

Create a vertex with a property

SELECT * FROM cypher('graph_name', $$ 
    CREATE (v {property: 'value'})
    RETURN v
$$) AS (vertex agtype);

Return the vertex with the specified value

SELECT * FROM cypher('graph_name', $$ 
    MATCH (v {property: 'value'}) 
    RETURN v
$$) AS (vertex agtype);

Return the vertex with the specified value using WHERE

SELECT * FROM cypher('graph_name', $$ 
    MATCH (v)
    WHERE v.property = 'value'
    RETURN v
$$) AS (vertex agtype);

Delete all vertices

SELECT * FROM cypher('graph_name', $$ 
    MATCH (v) 
    DELETE v
$$) AS (vertex agtype);

Create a vertex with a label and properties

SELECT * FROM cypher('graph_name', $$ 
    CREATE (v:Label {property1: 1, property2: 'value', property3: true}) 
    RETURN v
$$) AS (vertex agtype);

Get all vertices with a specified label

SELECT * FROM cypher('graph_name', $$ 
    MATCH (v:Label) 
    RETURN v
$$) AS (vertex agtype);

Get the vertex with the label and change the value of its property

SELECT * FROM cypher('graph_name', $$ 
    MATCH (v:Label)
    SET v.property1 = 0
    RETURN v
$$) AS (vertex agtype);

Remove the third property

SELECT * FROM cypher('graph_name', $$ 
    MATCH (v:Label)
    REMOVE v.property3
    RETURN v
$$) AS (vertex agtype);

Creating a new vertex and a relationship with our already existing node, returning the created path.

SELECT * FROM cypher('graph_name', $$ 
    MERGE p=(x:Label)-[r:relationship]->(y:newNode)
    RETURN p
$$) AS (path agtype);

References and manual

Apache AGE documentation
Apache AGE repository
Apache AGE website

How to export data from Apache AGE

Wendel Fernandes de Lana — Wed, 12 Jul 2023 01:55:55 +0000

Introduction

Exporting data from Apache AGE, an extension of PostgreSQL for graph data, can be a valuable task when you need to analyze or share your graph data with other systems. In this blog post, we will explore the process of exporting both edges and nodes from Apache AGE using the COPY command. By following the steps outlined below, you'll be able to export your graph data into CSV files for further analysis or integration.

Exporting Edges

To export edges from Apache AGE, you can utilize the COPY command with a Cypher query. The following command allows you to export the edges to a CSV file:
COPY (SELECT * FROM cypher('graph_name', $$ MATCH (a)-[e]->(b) RETURN start_id(e), label(a), end_id(e), label(b) $$) AS (start_id agtype, start_vertex_type agtype, end_id agtype, end_vertex_type agtype) ) TO '/path_to_csv/edges_graph.csv' DELIMITER ',' CSV HEADER;

This command executes a Cypher query that retrieves the desired edge information from the specified graph name. It selects the start ID, start vertex label, end ID, and end vertex label. The results are then written to a CSV file specified by the file path '/path_to_csv/edges_graph.csv' with a comma delimiter and a header row.

Exporting Nodes

Exporting nodes from Apache AGE requires manually retrieving the node properties and defining the column list as the CSV header. Let's assume we have a person vertex with properties like id, name, and age. To export this vertex, follow the code snippet below:

COPY (SELECT * FROM cypher('graph_name', $$ MATCH (a) RETURN a.id, a.name, a.age $$) AS (id agtype, name agtype, age agtype) ) TO '/path_to_csv/person_vertex_graph.csv' DELIMITER ',' CSV HEADER;
In this example, we execute a Cypher query that matches all nodes of the desired type (person). The query retrieves the node's ID, name, and age properties. The results are then written to a CSV file specified by the file path '/path_to_csv/person_vertex_graph.csv' with a comma delimiter and a header row that lists the column names.

Conclusion

Exporting data from Apache AGE is a straightforward process that allows you to extract graph data and save it in CSV format. By utilizing the COPY command and crafting appropriate Cypher queries, you can export both edges and nodes from your Apache AGE graph database. This exported data can then be utilized for various purposes, such as further analysis, integration with other systems, or sharing with collaborators.

Contribute

Apache AGE repository
Apache AGE website

Apache AGE: Watts-Strogatz Graph

Wendel Fernandes de Lana — Fri, 02 Jun 2023 16:22:44 +0000

Introduction

We will discuss in this post about the Watts-Strogatz graph, a feature that I've worked for Apache AGE and you can see the Pull Request for it here. First, let's introduce what is Apache AGE and Watts-Strogatz graph.

What is Apache AGE

Apache AGE is a PostgreSQL extension that provides graph database functionality. The goal of the project is to create single storage that can handle both relational and graph model data so that users can use standard ANSI SQL along with openCypher, the Graph query language.

Contribute to Apache AGE
Website: https://age.apache.org
Github: https://github.com/apache/age

What is Watts-Strogatz Graph

The Watts–Strogatz model was proposed by Duncan J. Watts and Steven Strogatz in their article published in 1998 in the Nature scientific journal. It is a random graph generation model that produces graphs with small-world properties, including short average path lengths and high clustering.

How the algorithm works
First create a ring over n nodes. Then each node in the ring is joined to its k nearest neighbors (or k-1 neighbors if k is odd). Then shortcuts are created by replacing some edges as follows: for each edge (u,v) in the underlying “n-ring with k nearest neighbors” with probability p replace it with a new edge (u,w) with uniformly random choice of existing node w.

Creating Watts-Strogatz Graph

Here is the syntax of the function:

age_create_watts_strogatz_graph(graph_name Name, n int, k int, p float
                                vertex_label_name Name DEFAULT = NULL,
                                vertex_properties agtype DEFAULT = NULL,
                                edge_label_name Name DEAULT = NULL,
                                edge_properties agtype DEFAULT = NULL,
                                bidirectional bool DEFAULT = true)

graph_name - Name of the graph to be created
n - The number of nodes
k - Each node is joined with its k nearest neighbors in a ring topology.
p -The probability of rewiring each edge
vertex_label_name - Name of the label to assign each vertex to.
vertex_properties - Property values to assign each vertex. Default is NULL
edge_label_name - Name of the label to assign each edge to.
edge_properties - Property values to assign each edge. Default is NULL
bidirectional - Bidirectional True or False. Default True.

Examples

SELECT * FROM 
    age_create_watts_strogatz_graph('gp1', 8, 2, 0.5,
                                    'vertices',
                                    NULL,
                                    'edges',
                                    NULL,
                                    true);

This query creates a graph named gp1 with 8 nodes. Each node is connected to its 2 nearest neighbors, and there is a 50% chance of rewiring each connection between two nodes. The node label is vertices, and the edge label is edges. Neither the vertices nor the edges have any properties, and the graph is bidirectional.

SELECT * FROM 
    age_create_watts_strogatz_graph('gp2', 8, 5, 0.5, 
                                    'vertices',
                                    '{"type":"vertex"}',
                                    'edges',
                                    '{"type":"edge", "connection":"strong"}',
                                    false);

This query creates a graph named gp2 with 8 nodes. Each node is connected to its 4 nearest neighbors, k-1 since k is odd, and there is a 50% chance of rewiring each connection between two nodes. The node label is vertices, and the edge label is edges. Each node has a property called type and its value is vertex. For the edges, there are 2 properties named type and cconnection, with the values edge and strong, respectively. This graph is not bidirectional.

Conclusion

When the functionality is merged into the source code, we will be able to create a Watts-Strogatz graph using the provided function and examples. This will enhance the graph generation algorithms in Apache AGE.

Omega Strikers: Guide to Gear and Awakenings with Apache AGE

Wendel Fernandes de Lana — Wed, 17 May 2023 21:50:30 +0000

Introduction

In today's article, I will begin by introducing Apache AGE and the game Omega Strikers. Following that, I will create a small graph to illustrate select data from the game. Finally, I will provide a conclusion summarizing the insights gained from this showcase.

What is Apache AGE

Apache AGE is a PostgreSQL extension that provides graph database functionality. AGE is an acronym for A Graph Extension, and is inspired by Bitnine’s fork of PostgreSQL 10, AgensGraph, which is a multi-model database. The goal of the project is to create single storage that can handle both relational and graph model data so that users can use standard ANSI SQL along with openCypher, the Graph query language.
Read more about Apache AGE here: https://age.apache.org/
Contribute to the Github repository: https://github.com/apache/age

What is Omega Strikers

Omega Strikers is a cross-platform game that offers an action-packed sports experience. In this game, you can play as a forward (also known as an attacker) or a goalie in a 3 versus 3 arena. The objective is to score goals while also trying to knock out your opponents. It is a free-to-play game available on PC, Nintendo Switch, PlayStation, Xbox, iOS, and Android platforms.
In this game, players have the option to choose awakenings and gears that serve as special powers for their strikers (characters). In today's article, I will create two builds for the striker Juliette and present them in an Apache AGE graph format.

There are more than 30 awakenings in the game, so I won't show them all. However, here you can see all the available gears in Omega Strikers, as there are only 8:

Graph Creation and Visualization

First and foremost, we need to create our graph. Let's name it omega_strikers:
SELECT create_graph('omega_strikers');

Now, let's create our vertices. First, the striker:
SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Striker) SET a.name = 'Juliette' $$) AS (a agtype);
Next, the gear:
SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Gear {name: 'Magnetic Soles', description: 'Crossing midfield grants 30% speed for 1s'}) $$) AS (a agtype);
Moving on to the awakenings:
SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Awakening {name: 'One-Two Punch', description: 'Hit 25% harder (5% to core) against targets you\'ve hit within 2.5s'}) $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Awakening {name: 'Built Different', description: 'Gain 40% size and your impact abilities hit 15% harder (3% to core)'}) $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Awakening {name: 'Perfect Form', description: 'Hits reduce other ability cooldowns by 12% up to 1.2s per hit (4%/.4s for light hits)'}) $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Awakening {name: 'Big Fish', description: 'Gain 40% size and 300 max stagger'}) $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Awakening {name: 'Peak Performance', description: 'Gain 250 max stagger and 0.007% speed per 100 max stagger'}) $$) AS (a agtype);
Lastly, let's create the vertex for the build:
SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Build {name: 'Meta Forward'}) $$) AS (a agtype);

Now, let's create the relationships by creating the edges:
SELECT * FROM cypher('omega_strikers', $$ MATCH (n:Build), (m:Gear) CREATE (n)<-[a:Recommended]-(m) RETURN a $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ MATCH (n:Build), (m:Awakening) CREATE (n)<-[a:Recommended]-(m) RETURN a $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ MATCH (n:Build), (m:Striker) CREATE (n)-[a:Recommended]->(m) RETURN a $$) AS (a agtype);
Notice that we don't need to use the WHERE clause because we only have the gear, awakenings, striker, and build nodes that we want to create relationships with. Let's take a look at the graph:

Futhermore, we could add another build, for that we need to create some other vertices for awakenings and gear too. Here's the code:
SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Gear {name: 'Vicious Vambrace', description: 'Restore stagger equal to 25% of the damage you deal (reduced on core)'}) $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Awakening {name: 'Bulk Up', description: 'Gain 250 max stagger and 1.5 power per 100 max stagger'}) $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Awakening {name: 'Tempo Swing', description: 'Hitting anything heals you for 4% of your max stagger (1.33% for light hits) and deals that amount as damage to the target hit.'}) $$) AS (a agtype);
Next, we create the vertex for the Tank/Bruiser Forward build and establish the corresponding edges:
SELECT * FROM cypher('omega_strikers', $$ CREATE (a:Build {name: 'Tank/Bruiser Forward'}) $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ MATCH (n:Build), (m:Gear) WHERE n.name = 'Tank/Bruiser Forward' AND m.name = 'Vicious Vambrace' CREATE (n)<-[a:Recommended]-(m) RETURN a $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ MATCH (n:Build), (m:Awakening) WHERE n.name = 'Tank/Bruiser Forward' AND (m.name = 'Big Fish' OR m.name='One-Two Punch' OR m.name = 'Bulk Up' OR m.name = 'Tempo Swing' OR m.name = 'Peak Performance') CREATE (n)<-[a:Recommended]-(m) RETURN a $$) AS (a agtype); SELECT * FROM cypher('omega_strikers', $$ MATCH (n:Build), (m:Striker) WHERE n.name = 'Tank/Bruiser Forward' AND m.name = 'Juliette' CREATE (n)-[a:Recommended]->(m) RETURN a $$) AS (a agtype);
Now, let's take a look at how the graph looks like:

Conclusion

We can utilize Apache AGE for various purposes, such as analyzing data from a game. This includes examining insights like player counts, gaming hours, and other related factors if we had a larger database containing all the players' and matches' data.
Additionally, we can explore, as we did, how the powers in the game, such as awakenings and gears, establish relationships with different types of builds (and possibily strikers). Apache AGE provides a versatile platform for conducting such analyses and gaining valuable insights.

Project: Label with a junction table and indexes

Wendel Fernandes de Lana — Fri, 05 May 2023 18:38:43 +0000

At present, Apache AGE does not support multiple labels in its vertices and edges. Furthermore, it utilizes the unique label identifier (ID) to create the unique identifier (ID) for the vertices and edges.
My proposal here is to present a alternative solution for that problem and discuss any details. I'm open for feedbacks about it.
Read about Apache AGE here: https://age.apache.org/
Github here: https://github.com/apache/age

Solution #1: Index for each label and a junction table

My solution will use the power of indexing to fetch data quickly. The table vertex will store a unique identifier (a simple sequential ID) and its properties as they exist today. The edge will have the same fields, in addition to their start_vertex and end_vertex. This will look like the image provided here:

Going forward, I will use the terms 'node' and 'vertex' interchangeably. To store the label in the node or edge, I've considered using an array to store all labels or creating columns for each label. However, both of these solutions have their drawbacks. If we use an array to store the label references within the node and edge data, it will be difficult to efficiently query and update data. If we create a separate column in the node and edge table for each label, we may end up with a large number of columns, which can become difficult to manage and maintain as the number of labels grows. Additionally, adding or removing label would require modifying the node or edge table schema, which can be disruptive.

Therefore, I propose another solution. We should create a table label, that store the label_id and label_name, and a junction table vertex_labels that links the table vertex and the table label. This junction table will have a composite primary key on the vertex_id and label_id columns, ensuring that it has no duplicates, and two foreign key columns: one that references the vertex table and one that references the label table. This allows a single node to have multiple label references, and the same solution applies to edges.
Here is an example of how the tables would look like:

As I mentioned earlier, we will be using indexes, so we can create two indexes on the node_labels table: one on the label_id column, and another on the composite key of node_id and label_id. The first index allows us to quickly locate all nodes with a specific label, while the second index allows us to quickly locate all labels associated with a specific node.

I think this is a simple solution, so it's feasible, and it solves both problems particularly well.

Apache AGE Setup for Contributing

Wendel Fernandes de Lana — Wed, 26 Apr 2023 01:53:58 +0000

Introduction

In this article, I will be discussing how to create a setup for contributing to the Apache AGE code. You must have a github account and PostgreSQL installed on your machine.

Tutorial

The first step to setup AGE is to fork the Apache AGE repository on Github.

Then, clone the forked repository to your local machine using Git. You can run the following command in your terminal replacing USER with your Github user:
git clone https://github.com/USER/apache-age.git

Add the path/to/postgres/include directory to your IDE environment's include path. This will ensure that the compiler recognizes dependencies such as postgres.h.

Finally, you can begin making modifications to the code such as fixing issues and improving the performance of functions. After making the necessary changes, navigate to the folder where you cloned your forked repository and run the following commands:
make clean
make PG_CONFIG=/path/to/postgres/bin/pg_config install

For more details access How to Contribute and the Contribution Guide
Apache AGE repository: https://github.com/apache/age
Apache AGE website: https://age.apache.org

Apache AGE 1.3 Release for PostgreSQL 13

Wendel Fernandes de Lana — Mon, 17 Apr 2023 23:19:32 +0000

Apache AGE has released a new version that is compatible with PostgreSQL version 13. This is great news for developers as they can now take advantage of Postgres' 13 features and improvements in performance. Besides, this new release has added new features and enhancements to the Apache AGE too.

Some of the key updates and fixes include the implementation of CALL ... [YIELD] for cypher functions, disallowing graph names with the empty string, and the optimization of the age_exists function. Additionally, there are fixes for various bugs related to clauses, commands, and labeling.

The CALL clause is an essential feature in database programming, which allows programmers to invoke a deployed procedure within the database. Additionally, the YIELD sub-clause enables the selection of specific result fields that are to be returned as newly-bound variables from the procedure call. This provides users with greater flexibility and control over the returned data, allowing for further processing within the remaining query.

I recommend taking a look at the full release notes for more detailed informations. Overall, this new version of Apache AGE should provide developers with improved functionality and performance.

Apache AGE website: https://age.apache.org
Apache AGE repository: https://github.com/apache/age
Release branch: https://github.com/apache/age/tree/release/PG13/1.3.0

How the VLE Works - The Internals of Apache AGE

Wendel Fernandes de Lana — Tue, 04 Apr 2023 19:11:44 +0000

Introduction

In this article I will give an introduction to the internals of Apache AGE, specifically how the VLE (Variable Length Expressions) works.

Prerequisites

A basic knowledge of PostgreSQL or any other Relational Database Management System (RDBMS), including an understanding of tables, schemas, and commonly used SQL queries such as SELECT, INSERT, DELETE, and UPDATE, is essential. Additionally, proficiency in JSON (JavaScript Object Notation) is also necessary.

How Variable-Length Expressions (VLE) Works

VLE allows users to express variable-length patterns in a graph, which can be useful for a wide range of applications, such as recommendation systems, fraud detection, and social network analysis.

The VLE function in Apache AGE is responsible for loading the relevant parts of the graph into memory and executing the path-finding algorithm. This algorithm is a graph traversal algorithm that works on a graph, not a tree. It searches for all paths of any length from all vertices to all vertices, which can result in a high number of computations, especially for large graphs. The speed of the algorithm is directly related to the size and connectedness of the graph and what it is looking for.

For instance, look at the following queries:
MATCH p=(u)-[*]-(v) RETURN p
MATCH (u)-[*]-(v) RETURN u
MATCH ()-[*]-() RETURN COUNT(1);

All of these queries will basically do the same thing - search for all paths of any length from all vertices to all vertices. This means that for a graph of 1 million nodes, this algorithm will be invoked up to 1 trillion times (the number of VxV combinations). Now, add that you are asking for all of the paths between each combination. So, each additional path length can add to the work done.
To minimize the workload, it is best to limit the algorithm's search scope by restricting where and how deeply it needs to look. This means restricting where it needs to look and how deeply it needs to look. Just because you restrict the input vertices doesn't mean that you restrict the interior vertices. The algorithm doesn't care about them, it only cares about interior edges.
It is worth mentioning that the VLE function in Apache AGE generates all valid paths from a start vertex and leaves the match against the terminal vertex to Postgres, due to implementation factors.

Apache AGE repository: https://github.com/apache/age
Apache AGE website: https://age.apache.org

How the Cypher Command Works - The Internals of Apache AGE

Wendel Fernandes de Lana — Fri, 31 Mar 2023 20:34:22 +0000

Introduction

In this article I will give an introduction to the internals of Apache AGE, specifically about the Apache AGE architecture and how the Cypher command works.

Prerequisites

Apache AGE Architecture and How the Cypher Command Works

OpenCypher is an open-source project that was initially developed by Neo4j to standardize the Cypher query language. Similar to SQL, openCypher is optimized for querying graph databases, providing a flexible and intuitive syntax for working with graph data.

Although openCypher is largely based on Cypher, there are some differences between the two. For example, openCypher includes several new features and functions, such as support for path patterns, aggregation, and subqueries.

To understand Apache AGE architecture, it is important to note that it is built on top of PostgreSQL and leverages hooks in PostgreSQL to modify certain processes. These hooks allow AGE to intercept queries and apply graph-specific processing to them, while still using the underlying PostgreSQL storage and indexing mechanisms. As a result, Apache AGE's architecture is very similar to PostgreSQL's, with some added components and functionality to support graph processing.

Query Parsing: the query is broken down into its constituent parts and analyzed in order to determine how it should be executed. In the case of Apache AGE, the parsing process also includes additional steps than standard PostgreSQL to handle the graph queries. It converts the openCypher query into an internal graph query representation, which is then optimized and executed.
Query Transform: the query transformation process involves taking a high-level Cypher query and transforming it into a lower-level representation that can be executed efficiently on a graph database.
Planner / Optimizer: it is responsible for generating an optimal query execution plan for a given openCypher query. The optimizer takes the input query and generates multiple candidate execution plans, each with a different set of operations and data access methods. The optimizer evaluates the candidate plans based on a set of cost metrics, such as execution time and resource usage, and selects the plan with the lowest overall cost.
Executor: it is responsible for executing the query plan generated by the query planner/optimizer. The executor receives the query plan and executes it against the underlying graph database.
Transaction / Cache Layer: it is responsible for managing transactions in the graph database. The transaction cache layer is a key component of Apache AGE's architecture that enables fast and efficient transaction processing.

PostgreSQL provides hooks that can be accessed after the Analyzer phase of its architecture, which Apache AGE leverages to intercept queries and apply graph-specific processing. However, because these hooks are not available during the parsing phase, AGE cannot directly support SQL being written in Cypher syntax.

References
https://thestack.technology/what-is-apache-age/. Accessed on 31/03/2023.

Apache AGE repository: https://github.com/apache/age
Apache AGE website: https://age.apache.org

How Data is Stored - The Internals of Apache AGE

Wendel Fernandes de Lana — Wed, 29 Mar 2023 22:34:06 +0000

Introduction

In this article I will give an introduction to the internals of Apache AGE, specifically how data is stored in AGE.

Prerequisites

How Data is Stored

Apache AGE uses a separate namespace in PostgreSQL for each individual graph, with the data for each graph being stored in the table ag_catalog.ag_graph.

oid - PostgreSQL identifier for the graph
name - The graph name
namespace - The schema name

When creating a graph, it also creates two tables within this namespace:_ag_label_vertex and _ag_label_edge, these will be the parent tables of any new vertex or edge label you create. Vertices and edges in AGE are stored as rows in PostgreSQL tables, with each row representing a single vertex or edge in the graph.

A label is generally a user-defined string that is assigned to vertices and edges in the graph to describe their type or category. The data for each label is stored in the table ag_label.

oid - Unique PostgreSQL identifier per label
name - The label name
graph - The oid of the graph to which this label belongs
id - The id for the label, unique per graph
kind - The type of label as v stands for vertex and e for edge
relation - The schema-qualified table name for the label

The data for all vertices and edges in a graph is stored at graph_name._ag_label_vertex and graph_name._ag_label_edge.
It's possible to see the data for all vertices or edges under a specific label using graph_name."Label".

Apache AGE repository: https://github.com/apache/age
Apache AGE website: https://age.apache.org

How Data is Represented - The Internals of Apache AGE

Wendel Fernandes de Lana — Wed, 29 Mar 2023 21:35:02 +0000

Introduction

In this article I will give an introduction to the internals of Apache AGE, specifically how data is represented in AGE.

Prerequisites

How Data is Represented

Apache AGE has extended PostgreSQL with a new data type called "agtype," which is based on PostgreSQL's JSONB implementation. The agtype data type provides support for three custom data types: vertices, edges, and paths, which enable graph database functionality within the PostgreSQL ecosystem.
In AGE, data is represented using a graph model, which consists of vertices and edges. Vertices represent entities in the data, such as people, places, or things, and edges represent the relationships or connections between those entities.
Each vertex and edge can have a set of properties, which are key-value pairs that provide additional information about the entity or relationship being represented.
A path refers to a sequence of edges that connect two vertices in a graph, which may include zero or more edges and vertices, and it can be either directed or undirected.

An agtype vertex consists of a graph ID, a label, and a set of properties

{ "id": 844424930131969, "label": "person", "properties": {"key": "value"} }::vertex

An edge is defined by its graph ID, a label that describes its relationship to the vertices it connects, the graph IDs of its start and end vertices, and a set of properties

{ "id": 1125899906842625, "label": "reports_to", "start_id": 844424930131969, "end_id": 844424930131970, "properties": {"key": "value"} }::edge

A path is a list of alternating vertices and edges

[vertex, edge, vertex, ...]::path

Apache AGE repository: https://github.com/apache/age
Apache AGE website: https://age.apache.org