DEV Community: Marco Aurélio Silva de Souza Júnior

How to use the official Apache AGE docker image

Marco Aurélio Silva de Souza Júnior — Thu, 10 Aug 2023 15:11:31 +0000

Pre-requisites

For this guide I'll be using Windows 11 with Arch Linux installed on WSL2, and Docker integrated. Docker Desktop needs to be installed on Windows.
This may work on anything that runs Docker, though.

Getting the image

Make sure docker daemon is running by starting Docker Desktop.

If you issue docker ps and it doesn't throw an error, you may be good to go.

Now go to the official Apache AGE docker hub page and copy the command:

docker pull apache/age

Run it on WSL terminal and it should appear in the list of docker images:

docker image ls
REPOSITORY          TAG           IMAGE ID       CREATED        SIZE
apache/age          latest        dc3b65a4c6fc   44 hours ago   1.34GB

Running the container

Now that you have the image, you need to run a container of it, but it needs very specific variables as per user documentation. From WSL terminal paste:

docker run \
    --name age  \
    -p 5455:5432 \
    -e POSTGRES_USER=postgresUser \
    -e POSTGRES_PASSWORD=postgresPW \
    -e POSTGRES_DB=postgresDB \
    -d \
    apache/age

Let me break down the command:

docker run: This is the basic command to start a new Docker container.
--name age: Assigns the name age to the container. This name can be used to reference the container in other Docker commands.
-p 5455:5432: Maps port 5432 inside the Docker container to port 5455 on the host machine (WSL). This is useful for connecting to the PostgreSQL service running inside the container from the host system.
-e POSTGRES_USER=postgresUser: Sets an environment variable POSTGRES_USER inside the container, assigning it the value postgresUser. This is the username used to connect to the PostgreSQL database.
-e POSTGRES_PASSWORD=postgresPW: Sets an environment variable POSTGRES_PASSWORD inside the container, assigning it the value postgresPW. This is the password used to connect to the PostgreSQL database.
-e POSTGRES_DB=postgresDB: Sets an environment variable POSTGRES_DB inside the container, assigning it the value postgresDB. This is the name of the database to which connections will be made by default.
-d: Runs the container in detached mode. This means that the container will run in the background, and you won't see its output in the terminal.
apache/age: This is the name of the Docker image to be used for the container. It refers to a specific image that has Apache AGE installed and configured.

With that there will be a running container on background:

Using Apache AGE from container

Now on Docker Desktop, click on age, the recently created container.

Now click "Terminal" and "Open in external terminal"

It will open your default terminal logged in to root.

Now run the command:

psql -h 0.0.0.0 -p 5432 -d postgresDB -U postgresUser

Immediately you will be inside psql, logged in to "postgresUser" in the "postgresDB" database, which were created upon the prior docker run command.

# psql -h 0.0.0.0 -p 5432 -d postgresDB -U postgresUser
psql (14.8 (Debian 14.8-1.pgdg120+1))
Type "help" for help.

postgresDB=#

Apache AGE comes already loaded, so you can start using it right away:

postgresDB=# SET search_path TO ag_catalog;
SET
postgresDB=# SELECT * FROM ag_graph;
 graphid | name | namespace
---------+------+-----------
   16950 | test | test
(1 row)

postgresDB=# SELECT * FROM ag_label;
       name       | graph | id | kind |       relation        |        seq_name
------------------+-------+----+------+-----------------------+-------------------------
 _ag_label_vertex | 16950 |  1 | v    | test._ag_label_vertex | _ag_label_vertex_id_seq
 _ag_label_edge   | 16950 |  2 | e    | test._ag_label_edge   | _ag_label_edge_id_seq
(2 rows)

postgresDB=#

And that's a wrap! Have fun!

I make these posts in order to guide people into the development of a new technology. If you find anything incorrect, I urge you to comment below so I can fix it. Thanks!

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

How to Install PostgreSQL from Source

Marco Aurélio Silva de Souza Júnior — Fri, 28 Jul 2023 19:15:55 +0000

Welcome to this guide on installing PostgreSQL from source on your machine. PostgreSQL is a powerful, open-source object-relational database system. Today, we'll walk through the process of setting it up from scratch.

Prerequisites

apt update && apt upgrade --yes && apt install sudo locales --yes

This command will update the list of packages and their versions on your machine (apt update), upgrade your system's installed packages (apt upgrade --yes), and then install sudo and locales (apt install sudo locales --yes).

The sudo package provides ordinary users with root permissions for specific commands, and locales is a system software package that supports localization - the adaptation of a product to meet the language, cultural and other requirements of a specific locale.

dpkg-reconfigure tzdata

This command reconfigures the timezone data on your machine. It's important to set this correctly to ensure all time-related processes on your system follow your local timezone.

adduser <username>

This command creates a new user. Replace <username> with your preferred username.

echo "<username> ALL=PASSWD: ALL" > /etc/sudoers.d/<username>

This line adds the newly created user to the sudoers file, which controls which users can run what software on which machines and as which users.

su - <username>

This command switches the current user to the newly created user.

sudo apt install htop git build-essential cmake libreadline-dev zlib1g-dev flex bison libicu-dev pkgconf vim --yes

This command installs various software and libraries needed to compile and run PostgreSQL. These include a text editor (vim), version control system (git), essential compilation tools (build-essential, cmake), a couple of libraries for handling compressed data (zlib1g-dev), text parsing (flex, bison), international components for Unicode (libicu-dev), and others.

Installing PostgreSQL

Now that our system is prepared, we can download the PostgreSQL source code, configure it, and install it.

First, download the PostgreSQL source code from the official website and unpack it or clone from GitHub. Then navigate into the directory.

Next, configure the installation with debug information and additional checks:

./configure \
    --enable-debug --enable-cassert \
    CFLAGS="-ggdb -Og -fno-omit-frame-pointer"

This command configures the source code to include debug information and enable assertion checks. The CFLAGS part sets compiler options to include debugging information in the executables (which helps when you need to debug something), disable optimizations (-Og), and not omit the frame pointer, which also helps with debugging.

make install

This command compiles the source code and installs the resulting binaries.

mkdir -p /usr/local/pgsql/data

This command creates a directory for the database files.

chown <username> /usr/local/pgsql/data

This command changes the ownership of the data directory to the new user we created earlier.

su - <username>

This command switches the current user to the new user.

Setting Environment Variables

Add these lines to your .profile file, typically located in your home directory (~/.profile):

LD_LIBRARY_PATH=/usr/local/pgsql/lib
export LD_LIBRARY_PATH
export PATH=/usr/local/pgsql/bin:$PATH
export DATA=/usr/local/pgsql/data

These commands set environment variables so that the system knows where to find the PostgreSQL executables and libraries, as well as where the data directory is.

Initializing the Database

Finally, let's initialize the database and start it up.

initdb -D $DATA

This command initializes the PostgreSQL database in the directory specified by the DATA environment variable.

pg_ctl -D $DATA start

This command starts the PostgreSQL database.

createdb test

This command creates a new database named test.

psql test

This command connects to the new test database with the psql client, and you're ready to start using PostgreSQL!

Conclusion:

Congratulations! You've successfully installed PostgreSQL from the source. This setup gives you full control over the configuration and enables debugging, which can be particularly helpful if you're developing an extension like Apache AGE or diving deeper into the PostgreSQL internals. Now you're ready to start creating and managing your databases!

Remember, when working directly with source installations, you have more control, but it also requires more responsibility for maintenance and updates. For production environments, it is generally recommended to use version-controlled packages provided by your operating system or trusted third-party repositories unless you have a good reason to compile from source.

I make these posts in order to guide people into the development of a new technology. If you find any misleading information, I urge you to comment below so I can fix it. Thanks!

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

How to Set Up a Developer Environment for Apache AGE using Docker

Marco Aurélio Silva de Souza Júnior — Fri, 28 Jul 2023 13:16:47 +0000

This is a guide on setting up your developer environment for Apache AGE using Docker on WSL. Docker simplifies your workflow and enhances your productivity. It allows you to create, deploy, and run applications by using containers. It will be helpful if you need to work on many versions of a software, like postgres.

Let's go into the steps!

Pre-requisites

This short tutorial was built using WSL2, with integrated docker.

Step 1: Create AGE Fork and Clone PostgreSQL

On your host OS, clone your own fork of Apache AGE and clone postgres in two side-by-side folders.

Step 2: Get Base Image and Install Build Essentials

I like using the image debian:stable-slim, as it is very lightweight. You can get it by pulling from docker hub:

docker run debian:stable-slim

Start by running a Docker container with the command:

docker run --name <new_image_name> -h <new_tag> -e LANG=C.UTF-8 -it debian:stable-slim /bin/bash -l

Next, we need to update our software packages and install the essential ones. Run these commands on the terminal inside the container, which just opened:

apt update && apt upgrade --yes && apt install sudo locales --yes
dpkg-reconfigure tzdata

Now, we'll create a new user and give them sudo permissions. Replace <your_username> with your chosen username:

adduser <your_username>
echo "<your_username> ALL=PASSWD: ALL" > /etc/sudoers.d/<your_username>
su - <your_username>

Lastly, we need to install some necessary tools. Run:

sudo apt install htop git build-essential cmake libreadline-dev zlib1g-dev flex bison libicu-dev pkgconf vim --yes

Step 3: Clone Image and Delete the Old One

To create a new Docker image from changes made to the current container, run:

docker image ls
docker commit debian:stable-slim <new_image_name:new_tag>

Then, you can remove the old container using:

docker rm debian:stable-slim

The newly created image will serve as your base to create other containers with different versions of postgres.

Step 4: Run the Container

Finally, we can run our new container. Make sure to replace the path placeholders with the actual source and destination paths for AGE:

docker run \
    --name <new_container_name> -h <new_host_name> \
    -v path/to/age/source:path/to/age/destination/inside/container \
    -it <new_image_name>:<hostname> /bin/bash

Congrats! You've now set up your developer environment for Apache AGE using Docker. This environment will be isolated from the other parts of your system, which helps to keep your workstation clean and organized.

Keep in mind that Docker is an extensive platform, and there's a lot more to learn. However, understanding these basics will significantly improve your workflow as a developer.

I make these posts in order to guide people into the development of a new technology. If you find anything incorrect, I urge you to comment below so I can fix it. Thanks!

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

Enhancing the create_complete_graph Function in Apache AGE

Marco Aurélio Silva de Souza Júnior — Thu, 27 Jul 2023 13:27:38 +0000

In this blog post, we're going to discuss an upgrade to the create_complete_graph function in Apache AGE, continuing our series. This function generates a complete graph with the given parameters, such as the graph name, number of nodes, and edge label. We'll be enhancing the function to add support for pre-modeled starting properties when creating nodes and edges.

To understand this modification, let's first dive into the create_complete_graph function in its initial state. The function takes in the following parameters:

'graph_name': The name of the graph.
'no_of_nodes': The number of nodes to create.
'edge_label': The label for the edges.
'node_label': The label for the nodes (optional).

In the existing code, node properties and edge properties are initialized as empty by default:

agtype *props = create_empty_agtype();

Then, these empty properties are passed to both insert_vertex_simple and insert_edge_simple functions while creating vertices and edges.

Modifications

Now, we'll modify the function to accept two additional parameters: 'edge_properties' and 'node_properties'. This will allow us to provide initial properties for edges and nodes while creating them.

Here are the steps to implement this enhancement:

Add Parameters: First, we need to add two more parameters in the age--1.3.0.sql file:

CREATE FUNCTION ag_catalog.create_complete_graph(
    graph_name name, 
    number_of_nodes int, 
    edge_label name, 
    edge_properties agtype = NULL,
    node_label name = NULL,
    node_properties agtype = NULL)
RETURNS void
LANGUAGE c
CALLED ON NULL INPUT
PARALLEL SAFE
AS 'MODULE_PATHNAME';

Declare Properties: Next, declare two agtype variables, one for edge_properties and one for node_properties. Initialize them to NULL.

agtype* edge_properties = NULL;
agtype* node_properties = NULL;

Assign Properties: Within the function, we will assign values to edge_properties and node_properties only if they are not NULL.

For edge_properties:

if(!PG_ARGISNULL(3))
{
    edge_properties = (agtype*)PG_GETARG_ARRAYTYPE_P(3);
}

For node_properties:

if(!PG_ARGISNULL(5))
{
    node_properties = (agtype*)PG_GETARG_ARRAYTYPE_P(5);
}

Modify Vertex and Edge Creation: Replace the props variable in insert_vertex_simple and insert_edge_simple function calls with node_properties and edge_properties respectively.

For vertex creation:

insert_vertex_simple(
    graph_id,
    vtx_name_str,
    object_graph_id,
    node_properties);

For edge creation:

insert_edge_simple(graph_id, edge_name_str,
                   object_graph_id, start_vertex_graph_id,
                   end_vertex_graph_id, edge_properties);

And that's it! You have now successfully added the ability to include pre-modeled starting properties for nodes and edges in the create_complete_graph function. This will allow developers to add their own properties to nodes and edges upon creation, making the function more flexible and customizable.

To call the function now you can put properties as agtype in the parameters, like this:

SELECT * FROM create_complete_graph(
    'test_graph', 5,
    'edges_label', '{"edge_property":"test"}'::agtype,
    'vertices_label', '{"node_property":"test"}'::agtype);

Remember to compile the modified extension and install it in your PostgreSQL server to make use of these enhancements.

I make these posts in order to guide people into the development of a new technology. If you find anything incorrect, I urge you to comment below so I can fix it. Thanks!

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

Setting Up pgAdmin 4 on Windows with PostgreSQL on WSL

Marco Aurélio Silva de Souza Júnior — Mon, 24 Jul 2023 17:57:39 +0000

In this blog post, we'll walk through the process of setting up pgAdmin 4, installed natively on Windows, to work with a PostgreSQL server running on Windows Subsystem for Linux (WSL). This guide assumes you have already installed PostgreSQL on WSL and pgAdmin 4 on your Windows system.

Step 1: Start the PostgreSQL Server on WSL

First, you need to start your PostgreSQL server on WSL. Use the pg_ctl command followed by -D and the directory of your database to start the server. The command should look something like this:

pg_ctl -D <your database directory> start

Upon running this command, you should see an output similar to the following:

waiting for server to start....2023-07-13 12:08:01.660 -03 [4659] LOG:  starting PostgreSQL 16beta1 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 13.1.1 20230429, 64-bit
2023-07-13 12:08:01.662 -03 [4659] LOG:  listening on IPv4 address "127.0.0.1", port 5432
2023-07-13 12:08:01.676 -03 [4659] LOG:  listening on Unix socket "/tmp/.s.PGSQL.5432"
2023-07-13 12:08:01.707 -03 [4662] LOG:  database system was shut down at 2023-06-30 17:18:29 -03
2023-07-13 12:08:01.738 -03 [4659] LOG:  database system is ready to accept connections

Take note of the IPv4 address and port number where the server is listening. In this case, it's "127.0.0.1" and port "5432".

Step 2: Add a New Server on pgAdmin

Next, open pgAdmin and add a new server. In the "Connection" tab, enter the IPv4 address and port number you noted in the previous step into the "Host name/address" and "Port" fields, respectively.

Step 3: Specify the Maintenance Database

The "Maintenance database" field should be filled with the name of your PostgreSQL database. If you're unsure of your database name, you can list all available databases by running the psql --list command on WSL.

Step 4: Enter Your Username and Password

The "Username" and "Password" fields should be filled with your PostgreSQL username and password, respectively. This is the same username and password you use to connect to PostgreSQL on WSL.

Step 5: Name Your Connection

Finally, give your connection a meaningful name in the "Name" field under the "General" tab. This will help you identify this connection in the future.

Once you've filled out all the necessary fields, save your new server configuration. You should now be able to connect to your PostgreSQL server on WSL using pgAdmin 4 on Windows.

I make these posts in order to guide people into the development of a new technology. If you find anything incorrect, I urge you to comment below so I can fix it. Thanks!

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

How to Fetch Different Kinds of Arguments in Apache AGE C-Language Functions

Marco Aurélio Silva de Souza Júnior — Tue, 11 Jul 2023 13:18:23 +0000

Creating a PostgreSQL extension in C, like Apache AGE, allows you to execute high-performance code directly in your database. One of the challenges is passing arguments to these C functions. Here's a simple guide to fetch different kinds of arguments in a C-language function of a PostgreSQL extension.

Before we start, make sure to include necessary PostgreSQL headers in your C file:

#include "postgres.h"
#include "fmgr.h"
#include "utils/builtins.h"

PostgreSQL provides the fmgr (Function Manager) module that includes macros for dealing with arguments.

Handling Scalar Arguments

For scalar arguments like integers or floats, use the PG_GETARG_ macros:

PG_FUNCTION_INFO_V1(add_integers);

Datum
add_integers(PG_FUNCTION_ARGS)
{
    int32 arg1 = PG_GETARG_INT32(0);  // Fetches the first argument
    int32 arg2 = PG_GETARG_INT32(1);  // Fetches the second argument

    PG_RETURN_INT32(arg1 + arg2);
}

Handling String Arguments

For text arguments, use the PG_GETARG_TEXT_P macro:

PG_FUNCTION_INFO_V1(echo_text);

Datum
echo_text(PG_FUNCTION_ARGS)
{
    text *arg1 = PG_GETARG_TEXT_P(0);
    char *cstr = text_to_cstring(arg1);

    PG_RETURN_TEXT_P(cstring_to_text(cstr));
}

Handling Array Arguments

For arrays, use the PG_GETARG_ARRAYTYPE_P macro:

PG_FUNCTION_INFO_V1(process_array);

Datum
process_array(PG_FUNCTION_ARGS)
{
    ArrayType *array = PG_GETARG_ARRAYTYPE_P(0);
    // Further processing...
}

Handling NULL Arguments

You can check if an argument is NULL using PG_ARGISNULL(index) macro:

PG_FUNCTION_INFO_V1(echo_or_default);

Datum
echo_or_default(PG_FUNCTION_ARGS)
{
    if (PG_ARGISNULL(0))
        PG_RETURN_TEXT_P(cstring_to_text("default"));
    else
    {
        text *arg1 = PG_GETARG_TEXT_P(0);
        char *cstr = text_to_cstring(arg1);

        PG_RETURN_TEXT_P(cstring_to_text(cstr));
    }
}

Concluding Remarks

This is a basic guide to fetching arguments in PostgreSQL C functions. Depending on the argument's type, you will need to use the appropriate PG_GETARG_ macros. Remember to consider NULL arguments as well. By mastering these techniques, you'll be able to harness the full power of PostgreSQL C-language functions.

Keep in mind that PostgreSQL's C API is vast and provides many more capabilities for dealing with complex data types, sets, and even triggering side effects on your database. Make sure to explore the official PostgreSQL documentation for a more comprehensive understanding.

Note: C-language functions can offer significant performance advantages but come with risks, especially around memory management. Be sure to thoroughly test any C functions you write for your PostgreSQL database.

I make these posts in order to guide people into the development of a new technology. If you find anything incorrect, I urge you to comment below so I can fix it. Thanks!

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

Introduction to Apache AGE - Graph Extension for PostgreSQL

Marco Aurélio Silva de Souza Júnior — Fri, 07 Jul 2023 13:22:49 +0000

As data grows more complex and interconnected, the need for efficient and effective tools to handle these relationships also expands. Apache AGE (A Graph Extension) is one such tool that brings the power of graph databases to PostgreSQL.

What is Apache AGE?

Apache AGE is an open-source project under Apache that provides graph database functionality to PostgreSQL. It extends the PostgreSQL capabilities, allowing it to store, query, and process graph data.

Benefits of Apache AGE

Seamless Integration with PostgreSQL

Apache AGE is a PostgreSQL extension, meaning existing PostgreSQL users can leverage AGE without changing their entire database infrastructure. It effectively adds graph functionality to an already powerful RDBMS.

Robust Query Language

Apache AGE uses the openCypher Query Language, enabling users to handle complex, interrelated data queries efficiently. openCypher is a highly popular and widely adopted language in the graph database industry, and its use in Apache AGE makes the tool versatile and robust.

Open Source

Apache AGE is an open-source project. This means it has a global community of developers constantly working on improving and enhancing its features. Users also benefit from extensive community support.

Use Cases

Apache AGE is used in various data-intensive fields where relationship exploration is critical. Some of these include social network analysis, real-time recommendation engines, fraud detection in financial transactions, and complex network management.

How to Start

Getting started with Apache AGE is easy. After installing PostgreSQL, you can add Apache AGE as an extension. AGE's comprehensive documentation and a supportive community will help you navigate this journey.

Conclusion

With data interconnectivity becoming a central part of modern application architectures, graph databases like Apache AGE are critical. By offering a seamless extension to PostgreSQL, Apache AGE is expanding the realm of possibility for developers handling complex data. With robust capabilities and an active open-source community, Apache AGE is a powerful tool for any developer's arsenal.

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

Apache AGE's ListGraphid

Marco Aurélio Silva de Souza Júnior — Wed, 28 Jun 2023 14:16:48 +0000

Greetings!

In today's post, we are going to explain a simple yet vital structure in Apache AGE, the PostgreSQL extension for graph databases: the ListGraphId structure. The aim is to help you understand how it functions, why it is essential, and how you can iterate over it.

What is the `ListGraphId` structure?

ListGraphId is a particular structure designed to store a list of nodes (vertices) in a graph. Each node is represented by a unique graphid, an int64 identifier.

The structure is defined in the age_graphid_ds.c file, which resides in the Apache AGE source code, and it looks like this:

typedef struct ListGraphId
{
    GraphIdNode *head;
    GraphIdNode *tail;
    int64 size;
} ListGraphId;

In ListGraphId, head points to the first node of the list, tail points to the last node, and size represents the total number of nodes in the list.

The `GraphIdNode` Structure

Before delving into ListGraphId, let's take a quick look at the GraphIdNode structure, which is the "node" of our ListGraphId. Here is its definition:

typedef struct GraphIdNode
{
    graphid id;
    struct GraphIdNode *next;
} GraphIdNode;

In GraphIdNode, id is the unique identifier (graphid) of a graph node (vertex), and next is a pointer to the next node in the list. Simple, isn't it?

Why `ListGraphId`?

You might wonder, why go through the trouble of creating a structure like ListGraphId when PostgreSQL has a List structure? The reason is quite straightforward. PostgreSQL's List structure does not directly support int64 data types, which are used for graph vertex identifiers (graphid). Therefore, ListGraphId was created as a more suitable alternative for handling lists of graphid.

Iterating over `ListGraphId`

Now let's dive into how to iterate over ListGraphId. Given its linked-list nature, we can employ a basic linked-list traversal technique.

Here is a simple function that prints all graphid in a ListGraphId:

void print_graph_ids(ListGraphId* listgraphid)
{
    GraphIdNode* curr_node;

    /* Start from the head node */
    for(curr_node = listgraphid->head; 
        curr_node != NULL; 
        curr_node = curr_node->next)
    {
        printf("%lld\n", curr_node->id);
    }
}

In the print_graph_ids function, we start with the head node of the ListGraphId and follow the next pointers until we reach the end of the list (NULL). At each node, we print out the graphid.

And voila, you've successfully iterated over a ListGraphId structure.

Wrapping Up

Understanding the ListGraphId structure and how to iterate over it is a crucial step for anyone looking to dive deeper into Apache AGE's internals or working on more advanced graph database manipulations with this extension.

This simple yet effective data structure forms the basis for more advanced operations and techniques in Apache AGE. In the coming blog posts, we'll explore more about these features and continue our journey into graph databases.

I hope this clarifies the ListGraphId structure's purpose and usage in Apache AGE. Do you have any questions or is there anything else you want to know? Please feel free to comment below.

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

Refactoring The Create Barbell Graph Function

Marco Aurélio Silva de Souza Júnior — Tue, 27 Jun 2023 14:32:59 +0000

On our last post for the source code tour of Apache AGE series, we implemented a function to generate a Barbell graph, and here is the result of it on AGE's GitHub repository.

But I thought it got a little hard to understand this function, as it has lots of steps just to create some vertexes and edges.

So let's refactor this function, implementing smaller helper functions in order to streamline the creation of vertexes and edges, therefore making it easier to read and get other kinds of pre-modeled graphs done.

First, let's put together in a struct every component we need to build nodes and edges:

typedef struct graph_components 
{
    Oid graph_oid;
    char* graph_name;
    int32 graph_size;

    char* vertex_label;
    int32 vertex_label_id;
    agtype* vertex_properties;
    Oid vtx_seq_id;

    char* edge_label;
    int32 edge_label_id;
    agtype* edge_properties;
    Oid edge_seq_id;

} graph_components;

There are too many error checks inside the function and it got messy, let's put it inside a function:

static void validate_barbell_function_args(PG_FUNCTION_ARGS)
{
    if (PG_ARGISNULL(0))
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                        errmsg("Graph name cannot be NULL")));
    }
    if (PG_ARGISNULL(1) || PG_GETARG_INT32(1) < 3)
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("Graph size cannot be NULL or lower than 3")));
    }
    if (PG_ARGISNULL(2) || PG_GETARG_INT32(2) < 0 )
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("Bridge size cannot be NULL or lower than 0")));
    }
    if (PG_ARGISNULL(5))
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("edge label cannot be NULL")));
    }
    if (!PG_ARGISNULL(3) && !PG_ARGISNULL(5) &&
        strcmp(NameStr(*(PG_GETARG_NAME(3))), 
               NameStr(*(PG_GETARG_NAME(5)))) == 0)
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("vertex and edge labels cannot be the same")));
    }
}

Now we just call it with validate_barbell_function_args(fcinfo);.

fcinfo is the structure FunctionCallInfo referenced by the macro PG_FUNCTION_ARGS, which contains all the arguments passed to the function.

Our main function is looking like this:

PG_FUNCTION_INFO_V1(age_create_barbell_graph);

Datum age_create_barbell_graph(PG_FUNCTION_ARGS) 
{
    validate_barbell_function_args(fcinfo);

    PG_RETURN_VOID();
}

Now that we know the arguments are valid, let's process them and put them inside our graph_components struct, which we will initialize in the main function now, just calling it graph:

PG_FUNCTION_INFO_V1(age_create_barbell_graph);

Datum age_create_barbell_graph(PG_FUNCTION_ARGS) 
{
    struct graph_components graph;

    validate_barbell_function_args(fcinfo);
    process_arguments(fcinfo, &graph);

    PG_RETURN_VOID();
}

static void process_arguments(PG_FUNCTION_ARGS, graph_components* graph)
{
    graph->graph_name = NameStr(*(PG_GETARG_NAME(0)));
    graph->graph_size = PG_GETARG_INT32(1);

    if (PG_ARGISNULL(3))    graph->vertex_label = AG_DEFAULT_LABEL_VERTEX;
    else                    graph->vertex_label = NameStr(*(PG_GETARG_NAME(3)));

    if (PG_ARGISNULL(4))    graph->vertex_properties = create_empty_agtype();
    else                    graph->vertex_properties = (agtype*)(PG_GETARG_DATUM(4));

    if (PG_ARGISNULL(5))    graph->edge_label = AG_DEFAULT_LABEL_EDGE;
    else                    graph->edge_label = NameStr(*(PG_GETARG_NAME(5)));

    if (PG_ARGISNULL(6))    graph->edge_properties = create_empty_agtype();
    else                    graph->edge_properties = (agtype*)(PG_GETARG_DATUM(6));
}

Here we fetch the arguments with PG_GETARG with the type we expect and convert them to the type we need. For example, we need the graph_name as a char*, but we receive it as a Name, so we convert it directly with the command NameStr(*(PG_GETARG_NAME(0))) - note that 0 is because it's the first parameter.

Now we can build our two complete graphs, but first let's change the create_complete_graph function to make it return the graph_id of the first / last created node:

We just change the last line of the function from PG_RETURN_VOID(); to

PG_RETURN_DATUM(GRAPHID_GET_DATUM(end_vertex_graph_id));

And on the age--1.3.0.sql file, on create_complete_graph function, we change RETURN void to RETURN graphid:

CREATE FUNCTION ag_catalog.create_complete_graph(graph_name name, nodes int, edge_label name, node_label name = NULL)
RETURNS graphid   -- change here!!!
LANGUAGE c
CALLED ON NULL INPUT
PARALLEL SAFE
AS 'MODULE_PATHNAME';

Now back to graph_generation.c file, we create two variables to store a graphid of a node from each complete graph, so we can connect them with a bridge later, then we store the returning value of create_complete_graph in these variables:

Datum root1, root2;

// create two separate complete graphs
root1 = DirectFunctionCall4(create_complete_graph, 
                            CStringGetDatum(graph.graph_name), 
                            Int32GetDatum(graph.graph_size),
                            CStringGetDatum(graph.edge_label), 
                            CStringGetDatum(graph.vertex_label));
root2 = DirectFunctionCall4(create_complete_graph, 
                            CStringGetDatum(graph.graph_name), 
                            Int32GetDatum(graph.graph_size),
                            CStringGetDatum(graph.edge_label), 
                            CStringGetDatum(graph.vertex_label));

With this we already have two complete graphs disconnected from each other.

Now let's build a bridge of n nodes connecting each complete graph.

But to build nodes and edges, we need to fetch its label and sequential id's. Let's make a function to each of them:

static void fetch_label_ids(graph_components* graph) 
{
    graph->graph_oid = get_graph_oid(graph->graph_name);
    graph->vertex_label_id = 
        get_label_id(graph->vertex_label, 
                     graph->graph_oid);
    graph->edge_label_id = 
        get_label_id(graph->edge_label, 
                     graph->graph_oid);
}

static void fetch_seq_ids(graph_components* graph)
{
    graph_cache_data* graph_cache;
    label_cache_data* vtx_cache;
    label_cache_data* edge_cache;

    graph_cache = search_graph_name_cache(graph->graph_name);
    vtx_cache = search_label_name_graph_cache(graph->vertex_label,
                                              graph->graph_oid);
    edge_cache = search_label_name_graph_cache(graph->edge_label,
                                               graph->graph_oid);

    graph->vtx_seq_id = 
        get_relname_relid(NameStr(vtx_cache->seq_name),
                          graph_cache->namespace);
    graph->edge_seq_id = 
        get_relname_relid(NameStr(edge_cache->seq_name),
                          graph_cache->namespace);
}

Now we call these functions inside the main create_barbell function, passing the address of the graph struct :

PG_FUNCTION_INFO_V1(age_create_barbell_graph);

Datum age_create_barbell_graph(PG_FUNCTION_ARGS) 
{
    struct graph_components graph;
    Datum root1, root2;

    validate_barbell_function_args(fcinfo);
    initialize_graph(fcinfo, &graph);

    // create two separate complete graphs
    root1 = DirectFunctionCall4(create_complete_graph, 
                                CStringGetDatum(graph.graph_name), 
                                Int32GetDatum(graph.graph_size),
                                CStringGetDatum(graph.edge_label), 
                                CStringGetDatum(graph.vertex_label));
    root2 = DirectFunctionCall4(create_complete_graph, 
                                CStringGetDatum(graph.graph_name), 
                                Int32GetDatum(graph.graph_size),
                                CStringGetDatum(graph.edge_label), 
                                CStringGetDatum(graph.vertex_label));

    fetch_label_ids(&graph);
    fetch_seq_ids(&graph);

    PG_RETURN_VOID();
}

Now let's connect these graphs already. We will make three functions to do this, create_vertex, connect_vertexes_by_graphid and insert_bridge:

static graphid create_vertex(graph_components* graph)
{
    int next_index;
    graphid new_graph_id; 

    next_index = nextval_internal(graph->vtx_seq_id, true);
    new_graph_id = make_graphid(graph->vertex_label_id, 
                                next_index);
    insert_vertex_simple(graph->graph_oid,
                         graph->vertex_label,
                         new_graph_id,
                         create_empty_agtype());
    return new_graph_id;
} 


static graphid connect_vertexes_by_graphid(graph_components* graph, 
                                           graphid out_vtx,
                                           graphid in_vtx)
{
    int nextval;
    graphid new_graphid; 

    nextval = nextval_internal(graph->edge_seq_id, true);
    new_graphid = make_graphid(graph->edge_label_id, nextval);

    insert_edge_simple(graph->graph_oid,
                       graph->edge_label,
                       new_graphid, out_vtx, in_vtx,
                       create_empty_agtype());
    return new_graphid;
}


static void insert_bridge(graph_components* graph, graphid beginning, 
                          graphid end, int32 bridge_size) 
{
    graphid current_graphid;
    graphid prior_graphid;

    prior_graphid = end;

    for (int i = 0; i<bridge_size; i++)
    {
        current_graphid = create_vertex(graph);
        connect_vertexes_by_graphid(graph, prior_graphid, current_graphid);
        prior_graphid = current_graphid;
    }

    // connect prior vertex to last index
    connect_vertexes_by_graphid(graph, prior_graphid, beginning);
}

With this made, we just fetch the bridge size from the function arguments and call insert_bridge, which will make our main function look like this:

PG_FUNCTION_INFO_V1(age_create_barbell_graph);

Datum age_create_barbell_graph(PG_FUNCTION_ARGS) 
{
    struct graph_components graph;
    Datum root1, root2;
    int32 bridge_size;

    validate_barbell_function_args(fcinfo);
    initialize_graph(fcinfo, &graph);

    // create two separate complete graphs
    root1 = DirectFunctionCall4(create_complete_graph, 
                                CStringGetDatum(graph.graph_name), 
                                Int32GetDatum(graph.graph_size),
                                CStringGetDatum(graph.edge_label), 
                                CStringGetDatum(graph.vertex_label));
    root2 = DirectFunctionCall4(create_complete_graph, 
                                CStringGetDatum(graph.graph_name), 
                                Int32GetDatum(graph.graph_size),
                                CStringGetDatum(graph.edge_label), 
                                CStringGetDatum(graph.vertex_label));

    fetch_label_ids(&graph);
    fetch_seq_ids(&graph);

    // connect two vertexes with a path of n vertexes
    bridge_size = fcinfo->arg[2];
    insert_bridge(&graph, DATUM_GET_GRAPHID(root1), 
                  DATUM_GET_GRAPHID(root2), bridge_size);

    PG_RETURN_DATUM(root1);
}

Also we changed the return value to be the graphid root1, so it may be used to make other pre-modeled graph functions in the future.

Now to call the function on psql interface, we issue the command:

SELECT * FROM age_create_barbell_graph('testing_graph',5,3,'nodeLabel','{}','edgeLabel','{}');

This will create a Barbell graph with two complete graphs with 5 nodes each and a bridge of 3 nodes connecting them.

I make these posts in order to guide people into the development of a new technology. If you find anything incorrect, I urge you to comment below so I can fix it. Thanks!

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

Developing a Barbell Graph Function with Apache AGE

Marco Aurélio Silva de Souza Júnior — Thu, 22 Jun 2023 14:16:05 +0000

Now that we saw how to develop a function to create a complete graph on Apache AGE, we are going to create a function to develop a Barbell graph - two complete graphs (cliques) connected by a bridge path. We will guide you through each step, explaining the components of the function to help you understand how it works.

We start by declaring our function with the macro PG_FUNCTION_INFO_V1. This is used in PostgreSQL to bind our C function to SQL commands. In our case, we're defining a function called age_create_barbell_graph.

PG_FUNCTION_INFO_V1(age_create_barbell_graph);

This function takes a graph name, the number of vertices in each complete graph (m), the number of vertices in the bridge path (n), labels for vertices and edges, and properties for vertices and edges.

Our main function is age_create_barbell_graph, and it uses the PG_FUNCTION_ARGS macro as a shortcut to pass arguments from SQL commands to our C function.

Datum age_create_barbell_graph(PG_FUNCTION_ARGS)

We need to declare all variables in the beginning of the function, otherwise it will issue an warning when compiling: ISO C90 forbids mixed declarations and code [-Wdeclaration-after-statement]

    FunctionCallInfo arguments;
    Oid graph_oid;
    Name graph_name;
    char* graph_name_str;

    int64 start_node_index, end_node_index, nextval;

    Name node_label_name = NULL;
    int32 node_label_id;
    char* node_label_str;

    Name edge_label_name;
    int32 edge_label_id;
    char* edge_label_str;

    graphid object_graph_id;
    graphid start_node_graph_id;
    graphid end_node_graph_id;

    graph_cache_data* graph_cache;
    label_cache_data* edge_cache;

    agtype* properties = NULL;

    arguments = fcinfo;

We have to check if any mandatory arguments are null. This is essential because it prevents any errors from occurring later in our function. For example, if the graph name or size is null or invalid, the function throws an error.
Here we check the arguments and process it immediately after:

    // Checking for possible NULL arguments 
    // Name graph_name
    if (PG_ARGISNULL(0))
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                        errmsg("Graph name cannot be NULL")));
    }
    graph_name = PG_GETARG_NAME(0);
    graph_name_str = NameStr(*graph_name);

    // int graph size (number of nodes in each complete graph)
    if (PG_ARGISNULL(1) && PG_GETARG_INT32(1) < 3)
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("Graph size cannot be NULL or lower than 3")));
    }

    /*
     * int64 bridge_size: currently only stays at zero.
     * to do: implement bridge with variable number of nodes.
    */ 
    if (PG_ARGISNULL(2) || PG_GETARG_INT32(2) < 0 )
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("Bridge size cannot be NULL or lower than 0")));
    }

    // node label: if null, gets default label, which is "_ag_label_vertex"
    if (PG_ARGISNULL(3)) 
    {
        namestrcpy(node_label_name, AG_DEFAULT_LABEL_VERTEX);
    }
    else 
    {
        node_label_name = PG_GETARG_NAME(3);
    }
    node_label_str = NameStr(*node_label_name);

    /* 
    * Name edge_label 
    */
    if (PG_ARGISNULL(5))
    {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("edge label can not be NULL")));
    }
    edge_label_name = PG_GETARG_NAME(5);
    edge_label_str = NameStr(*edge_label_name);

We use DirectFunctionCall4 to call the function create_complete_graph twice - once for each complete graph in our Barbell Graph. This function creates a complete graph with a given name, size, edge label, and vertex label.

DirectFunctionCall4(create_complete_graph, arguments->arg[0], 
                                               arguments->arg[1],
                                               arguments->arg[5], 
                                               arguments->arg[3]);

We need to get the unique identifiers (oid) for our graph and labels. This is done using the get_graph_oid and get_label_id functions.

graph_oid = get_graph_oid(graph_name_str);
node_label_id = get_label_id(node_label_str, graph_oid);
edge_label_id = get_label_id(edge_label_str, graph_oid);

The graph and edge caches are then searched to provide access to necessary nodes to be connected with edges later.

graph_cache = search_graph_name_cache(graph_name_str);
edge_cache = search_label_name_graph_cache(edge_label_str,graph_oid);

We use the get_nextval_internal function to get the next internal value in the graph, so a new object (node or edge) graph id can be composed.

nextval = get_nextval_internal(graph_cache, edge_cache);

Finally, we use the insert_edge_simple function to connect two nodes - one from each complete graph. This creates the bridge that links our two complete graphs into a Barbell Graph.

insert_edge_simple(graph_oid, edge_label_str,
                       object_graph_id, start_node_graph_id,
                       end_node_graph_id, properties);

And that's it! Our function ends by returning void using PG_RETURN_VOID(), meaning it doesn't return any value. The graph is directly created in the database.

Including the Function in the PostgreSQL Catalog

The function you've just created needs to be recognized and executed by PostgreSQL. To achieve this, we have to add a corresponding entry in PostgreSQL's catalog. This is done by including the function in the age--1.3.0.sql file. This file is the SQL script that sets up the PostgreSQL functions when Apache AGE is installed.

Here's the code you need to add to the age--1.3.0.sql file:

CREATE FUNCTION ag_catalog.age_create_barbell_graph(
    graph_name name,
    graph_size int,
    bridge_size int,
    node_label name = NULL,
    node_properties agtype = NULL,
    edge_label name = NULL,
    edge_properties agtype = NULL)
RETURNS void
LANGUAGE c
CALLED ON NULL INPUT
PARALLEL SAFE
AS 'MODULE_PATHNAME';

This CREATE FUNCTION command adds our age_create_barbell_graph function to the ag_catalog, which is the PostgreSQL catalog for Apache AGE.

The structure of the CREATE FUNCTION command matches the structure of the C function we've defined earlier. The parameters, their types, and their default values are all listed here, along with the function's return type (void).

LANGUAGE c specifies that the function is written in C.

CALLED ON NULL INPUT means the function will still be called even if some of its arguments are null.

PARALLEL SAFE indicates that this function can be safely run in parallel mode by PostgreSQL.

Finally, 'MODULE_PATHNAME' is a placeholder for the shared library where the C function is located.

After adding this to the age--1.3.0.sql file and installing Apache AGE, PostgreSQL will recognize and be able to execute your age_create_barbell_graph function. Now you can use this function to create barbell graphs directly from your SQL commands!

Calling the Function from the psql Interface

Now that our function is defined and registered with PostgreSQL, let's go over how to call it from the psql interface.

Here are the commands to load the Apache AGE extension and set the search path:

CREATE EXTENSION age;

LOAD 'age';
SET search_path TO ag_catalog;

SET search_path TO ag_catalog; is setting the search path to ag_catalog, the PostgreSQL catalog for Apache AGE. This means that the function we're going to call is located in this catalog.

Now we can call our age_create_barbell_graph function. Here's the command to do so:

SELECT age_create_barbell_graph('barbell',5,0,'vlabel',NULL,'elabel',NULL);

We use a SELECT statement to call the function. The parameters passed are the name of the graph ('barbell'), the number of vertices in each complete graph (5), the number of vertices in the bridge path (0), and the labels for the vertices and edges ('vlabel' and 'elabel', respectively). We're passing NULL for the properties of vertices and edges as we haven't defined any.

As you might notice, the bridge size and properties arguments are not implemented in this function. That's an exercise for you - try modifying the function to include these features, to further enhance the functionality and flexibility of your barbell graphs!

This concludes our guide on developing a Barbell graph function using Apache AGE. Remember that practice is key in mastering these concepts, so don't hesitate to experiment and try implementing additional features yourself!

I make these posts in order to guide people into the development of a new technology. If you find anything incorrect, I urge you to comment below so I can fix it. Thanks!

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation: https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age

Apache AGE and Postgres Source Code Tour: Understanding the Complete Graph Function

Marco Aurélio Silva de Souza Júnior — Tue, 13 Jun 2023 15:00:40 +0000

In the following blog post, we are going to review a function used to create a complete graph within the Apache AGE. A complete graph is a simple undirected graph in which every pair of distinct vertices is connected by a unique edge. This will be important for the Barbell Graph function we will be creating later.

To begin, let's break down this code section by section:

Variable Declarations: The function begins by declaring various variables that will be used throughout the code. These include variables for the graph ID, graph name, number of vertices, vertex and edge labels, and various cache data.

Oid graph_id;
Name graph_name;

int64 no_vertices;
int64 i,j,vid = 1, eid, start_vid, end_vid;

...

Error Handling: Next, the function checks if any of the arguments (i.e., the graph name, number of nodes, and edge label) are null, and if so, throws an error.

if (PG_ARGISNULL(0))
{
    ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("graph name can not be NULL")));
}

...

Argument Assignments and Conversions: The function assigns argument variables and sets defaults for non-obligatory ones. It also converts names to strings for easier manipulation. If a vertex label is given as a parameter and it's the same as the edge label, the function throws an error.

graph_name = PG_GETARG_NAME(0);
no_vertices = (int64) PG_GETARG_INT64(1);
edge_label_name = PG_GETARG_NAME(2);
...

...

Graph Creation and Assertions: If the graph doesn't exist, it creates an empty one. It assigns the edge and node properties, checks if the labels exist, and creates them if they don't. The function also retrieves the label IDs to be used in creating graph IDs.

if (!graph_exists(graph_name_str))
{
    DirectFunctionCall1(create_graph, CStringGetDatum(graph_name));
}
graph_id = get_graph_oid(graph_name_str);
...

...

Vertices Creation: The function creates vertices using the sequential ID for each vertex. For each vertex, it generates a unique ID and inserts the vertex into the graph.

for (i=(int64)1;i<=no_vertices;i++)
{   
    vid = nextval_internal(vtx_seq_id, true);
    object_graph_id = make_graphid(vtx_label_id, vid);
    insert_vertex_simple(
        graph_id,
        vtx_name_str,
        object_graph_id,
        node_properties);
}

Edges Creation: Finally, the function creates edges connecting every pair of vertices in the graph. It uses the last ID of the vertices created to create edges between all possible vertex pairs. After creating the edge, it inserts it into the graph.

for (i = 1;i<=no_vertices-1;i++)
{   
    start_vid = lid-no_vertices+i;
    for(j=i+1;j<=no_vertices;j++)
    {  
        end_vid = lid-no_vertices+j;
        eid = nextval_internal(edge_seq_id, true);
        object_graph_id = make_graphid(edge_label_id, eid);

        start_vertex_graph_id = make_graphid(vtx_label_id, start_vid);
        end_vertex_graph_id = make_graphid(vtx_label_id, end_vid);
        insert_edge_simple(graph_id, edge_name_str,
                        object_graph_id, start_vertex_graph_id,
                        end_vertex_graph_id, edge_properties);
    }
}

In summary, this function is a comprehensive example of how to create a complete graph in Apache AGE using PostgreSQL. It provides the ability to customize the graph name, number of nodes, edge label, and node properties, while ensuring that all possible edges between nodes are created. It is a robust tool that is essential in any graph database.

It is a good starting point to understand how Apache AGE works.

Check Apache AGE: https://age.apache.org/.

Overview — Apache AGE master documentation. https://age.apache.org/age-manual/master/intro/overview.html.

GitHub - apache/age: https://github.com/apache/age..

Source code tour on Apache AGE & Postgres - Lists

Marco Aurélio Silva de Souza Júnior — Mon, 29 May 2023 23:06:34 +0000

Introduction

In PostgreSQL, the ListCell struct is a key component for implementing linked lists, which we will use frequently on our contribution to Apache AGE. You can check its implementation in PostgreSQL's official GitHub Repository.

This blog post provides a concise overview of the ListCell struct, its purpose, and significance, along with an example of iterating over a List using ListCell.

The ListCell Struct:

The ListCell struct, defined in pg_list.h, has two members:

next: a pointer to the next ListCell in the linked list, enabling traversal.
data: a void pointer to store the actual data in each ListCell.

Iterating over a List using ListCell:

Let's consider an example of iterating over a list using ListCell. Assume we have a List of integers, and we want to print each element:

List *myList; // Assume we have a List containing integers

ListCell *cell;
foreach(cell, myList)
{
    int *value = (int *) lfirst(cell);
    printf("%d\n", *value);
}

In this example, we declare a ListCell pointer cell and use the foreach macro provided by PostgreSQL to iterate over the myList. Within the loop, we extract the integer value stored in each ListCell using lfirst, which returns a void pointer. We then cast it to an int pointer and dereference it to obtain the actual value, which we print.

The ListCell struct is a vital component of PostgreSQL's linked list implementation. It facilitates the creation and manipulation of dynamic lists throughout the PostgreSQL source code, showcasing the system's flexibility and versatility. By utilizing ListCell and its associated macros, such as foreach, iterating over lists becomes straightforward and efficient.

Please note that this condensed blog post provides a high-level overview of the ListCell struct and an example of iteration. For more detailed information, refer to the official PostgreSQL documentation and source code.

Apache AGE. https://age.apache.org/.
GitHub - apache/age - https://github.com/apache/age

DEV Community: Marco Aurélio Silva de Souza Júnior

How to use the official Apache AGE docker image

Pre-requisites

Getting the image

Running the container

Using Apache AGE from container

How to Install PostgreSQL from Source

Prerequisites

Installing PostgreSQL

Setting Environment Variables

Initializing the Database

How to Set Up a Developer Environment for Apache AGE using Docker

Pre-requisites

Step 1: Create AGE Fork and Clone PostgreSQL

Step 2: Get Base Image and Install Build Essentials

Step 3: Clone Image and Delete the Old One

Step 4: Run the Container

Enhancing the create_complete_graph Function in Apache AGE

Modifications

Setting Up pgAdmin 4 on Windows with PostgreSQL on WSL

How to Fetch Different Kinds of Arguments in Apache AGE C-Language Functions

Handling Scalar Arguments

Handling String Arguments

Handling Array Arguments

Handling NULL Arguments

Concluding Remarks

Introduction to Apache AGE - Graph Extension for PostgreSQL

What is Apache AGE?

Benefits of Apache AGE

Seamless Integration with PostgreSQL

Robust Query Language

Open Source

Use Cases

How to Start

Conclusion

Apache AGE's ListGraphid

What is the ListGraphId structure?

The GraphIdNode Structure

Why ListGraphId?

Iterating over ListGraphId

Wrapping Up

Refactoring The Create Barbell Graph Function

Developing a Barbell Graph Function with Apache AGE

Including the Function in the PostgreSQL Catalog

Calling the Function from the psql Interface

Apache AGE and Postgres Source Code Tour: Understanding the Complete Graph Function

Source code tour on Apache AGE & Postgres - Lists

Introduction

The ListCell Struct:

Iterating over a List using ListCell:

What is the `ListGraphId` structure?

The `GraphIdNode` Structure

Why `ListGraphId`?

Iterating over `ListGraphId`