DEV Community: Tito Osadebey

Ultimate Guide to Open Source Contribution (Part 2)

Tito Osadebey — Sat, 29 Jul 2023 11:40:53 +0000

In the previous article, we presented a basic template to Open Source contributions and as stated also, we would be delving into how we can use that template to contribute to Apache AGE.

For a practical approach, we are looking at how the cos() function was implemented in AGE.

Note: Before creating a function in AGE, it should supported by Neo4j Cypher and/or PostgreSQL else there should be a very valid reason.

Firstly, we check similar functions to see the structure to follow accordingly and then implement in age--1.3.0.sql and src/backend/utils/adt/agtype.c files.

In age--1.3.0.sql, the function is declared:

CREATE FUNCTION ag_catalog.age_cos(variadic "any")
RETURNS agtype
LANGUAGE c
IMMUTABLE
PARALLEL SAFE
AS 'MODULE_PATHNAME';

Then the function is created or added in agtype.c:

PG_FUNCTION_INFO_V1(age_cos);

Datum age_cos(PG_FUNCTION_ARGS)
{
    int nargs;
    Datum *args;
    bool *nulls;
    Oid *types;
    agtype_value agtv_result;
    float8 angle;
    float8 result;
    bool is_null = true;

    /* extract argument values */
    nargs = extract_variadic_args(fcinfo, 0, true, &args, &types, &nulls);

    /* check number of args */
    if (nargs != 1)
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                        errmsg("cos() invalid number of arguments")));

    /* check for a null input */
    if (nargs < 0 || nulls[0])
        PG_RETURN_NULL();

    /*
     * cos() supports integer, float, and numeric or the agtype integer, float,
     * and numeric for the angle
     */

    angle = get_float_compatible_arg(args[0], types[0], "cos", &is_null);

    /* check for a agtype null input */
    if (is_null)
        PG_RETURN_NULL();

    /* We need the numeric input as a float8 so that we can pass it off to PG */
    result = DatumGetFloat8(DirectFunctionCall1(dcos,
                                                Float8GetDatum(angle)));

    /* build the result */
    agtv_result.type = AGTV_FLOAT;
    agtv_result.val.float_value = result;

    PG_RETURN_POINTER(agtype_value_to_agtype(&agtv_result));
}

After creating a function, you should also write tests for that function to ensure it works efficiently. These tests are added to files in the regress/ directory in the repository depending on the function added. In the case of cos() function, the files we are interested in are regress/expected/expr.out and regress/sql/expr.sql.

These files are used to test the functions and compare the output of different files. If the output or result from expr.sql is different from that in expr.out then the tests will fail. Hence, ensure the tests pass before making a pull request.

Conclusion
This is just a basic guide to contributing to an open source project like AGE. The steps stated in the first article can be implemented in any project. Remember, the most important part of contribution is testing, this ensures you don't push a code that causes "hiroshima" to the project.

References
Apache AGE website
Apache AGE project

Ultimate Guide to Open Source Contribution (Part 1)

Tito Osadebey — Tue, 18 Jul 2023 09:15:04 +0000

Introduction

Contributing to Open Source projects is one of the best platforms to gain experience in the software engineering space. It also makes a prospective employer see how diligent an applicant is as an aspiring or experienced Software Engineer and makes the applicant standout in the recruitment stages of a job opportunity.

In this article, we would be looking at how to contribute to Apache AGE by creating a function. Unlike adding or editing a README, this gives you an edge.

Steps to Contribution
Creating a function in Open source projects like AGE is quite daunting for a newbie and that's why I suggest you follow the steps below for an easy process.

Check for Functions not implemented that would be a great addition - This particular step is the foundation for any contribution. You sure do not want to add a function that already exists because that makes you seem lazy and a copy, so do a deep research of the project.
Look at similar functions and the syntax - This will give you and idea on how to implement your supposed function.
For example, if there's a function in the project that returns the max of 2 numbers and there's no min function present, then the syntax of the max function should be a reference for the min() function you are to create. This step also is important for contributing to other Open Source projects.
Write code in associated files - Still citing the max() function for the min() function to be created, You should also take note of the files in which the max() function was implemented and follow suit for the min() function.
Test the function - This is the most important step because you don't want to push an erroneous code to an open source codebase (it's a red flag). Test the code on your local system and ensure it works properly. If the function gives an error, debug and test again till it gives no errors.
Make a PR - This is equivalent to submitting a solution and expecting feedback for the solution. Do not feel bad if your PR does not get merged as there might be many reasons such as:
a. The solution might not in the current scope of projects.
b. It might not be according to their contribution standards. Hence, you should always align your PRs accordingly.

Optional: Add more cases to the function. If the max() function takes only int values, you can add more functionalities in the min() function to consider float values.

Conclusion
This is an ideal template to start contributing to Open Source projects. In the next blog post, we would make practical examples on how to contribute to Apache AGE.

References
Apache AGE website
Apache AGE project

Getting Started with Apache AGE: A Comprehensive Guide (Part 3)

Tito Osadebey — Wed, 10 May 2023 12:35:01 +0000

In this article, we would be looking at AGE Viewer. AGE Viewer is a web-based tool that is used to visualize the relationships between nodes, edges and the output of cypher queries in AGE. It can handle large and complex graph data.

Installing AGE Viewer
npm is required to install AGE Viewer. You can install through the terminal with:

nvm install 14.16.0

Next, go into the directory where you downloaded AGE and download AGE Viewer there:

git clone https://github.com/apache/age-viewer.git

Launching AGE Viewer

cd age-viewer
npm run setup
npm run start

This should open AGE Viewer in a browser on your PC and you should see some empty boxes requiring details to connect to a database. Ensure you type in the right details. In my case, it will be:

If connected successfully, you should see something similar to the image below with your details, the nodes and edges.

Visualizing Queries
We can visualize queries now that we have AGE Viewer set up. Let’s see all the nodes present in this graph.

SELECT * FROM cypher('test', $$ MATCH (v) RETURN v $$) as (v agtype);

We can also visualize the relationship between nodes that have similar tribes:

SELECT * FROM cypher('test', $$ MATCH (v)-[r:IS]-(v2) RETURN v, r, v2 $$) AS (v agtype, r agtype, v2 agtype);

Conclusion
Visualizing data is very important for efficient data extraction, analysis and event prediction. AGE Viewer helps ease this process with its awesome functionalities. In this post, we just scratched the surface on what is an ideal tool for data visualization in graph database systems which would be a great asset for data scientists, analysts and everyone working with data.

References
For more information on Apache AGE, visit:
AGE website
AGE GitHub
AGE Viewer

Getting Started with Apache AGE: A Comprehensive Guide (Part 2)

Tito Osadebey — Thu, 27 Apr 2023 22:06:03 +0000

In the previous part of this series, we looked at the introduction to Apache AGE as a graph analysis tool and followed up with steps to installing and setting it up. In continuation, we’ll be creating a graph, and querying it using Cypher queries.

Creating a graph in AGE
Following up with the steps in part 1, we can create a graph by running the statement:

SELECT create_graph('test');

To check if the graph was created successfully, run the statement that shows a table of graphs created in the database:

SELECT * FROM ag_graph;

After the graph is created, we need to add nodes and/or edges (otherwise called relationships) to the graph using cypher queries. For a brief introduction to graphs and its analysis, click here.

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "Tito", bornin: "Warri", tribe: "Igbo"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "Tobe", bornin: "Warri", tribe: "Igbo"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "Tuoyo", bornin: "Warri", tribe: "Itsekiri"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "Austen", bornin: "Windsor"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "David", bornin: "Benin", tribe: "Bini"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "Ikechukwu", bornin: "Benin", tribe: "Igbo"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "Mariela", bornin: "Mexico City"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "Ayomide", bornin: "Benin", tribe: "Yoruba"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Person {name: "Dotun", bornin: "Windsor", tribe: "Yoruba"}) $$) AS (a agtype);

9 nodes were created with the statements above. These nodes have a label Person and varying properties for each node such as name, bornin and tribe.
Furthermore, we can add more nodes with label City to the graph to make it robust.

SELECT * FROM cypher('test',  $$ CREATE (n:City {name: "Warri"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:City {name: "Benin"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:City {name: "Windsor"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:City {name: "Mexico City"}) $$) AS (a agtype);

We can also add nodes with label Tribe:

SELECT * FROM cypher('test',  $$ CREATE (n:Tribe {name: "Igbo"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Tribe {name: "Bini"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Tribe {name: "Yoruba"}) $$) AS (a agtype);

SELECT * FROM cypher('test',  $$ CREATE (n:Tribe {name: "Itsekiri"}) $$) AS (a agtype);

Now let’s create some edges (relationships) between the nodes.
Create an edge between nodes with label Person and City:

SELECT * FROM cypher('test',  $$ MATCH (a:Person), (b:City) WHERE a.bornIn = b.name CREATE (a)-[r:BORN_IN]->(b) RETURN r $$) AS (r agtype);

For an edge between nodes with label Person and Tribe:

SELECT * FROM cypher('test',  $$ MATCH (a:Person), (b:Tribe) WHERE a.tribe = b.name CREATE (a)-[r:IS]->(b) RETURN r $$) AS (r agtype);

Querying the graph

To find out persons born in certain cities, we can query the graph with the statement:

SELECT * FROM cypher('test',  $$ MATCH (a:Person)-[r]- (b:Tribe) WHERE a.tribe = b.name RETURN a, r, b $$) AS (a agtype, r agtype, b agtype);

This will return all Person nodes whose property tribe matches the name in Tribe nodes.

SELECT * FROM cypher('test',  $$ MATCH (a:Person)-[r]- (b:City) WHERE a.bornIn = b.name RETURN a, r, b $$) AS (a agtype, r agtype, b agtype);

This returns all Person nodes whose property bornIn matches the name in City nodes.

Conclusion
In this post, we created a graph using AGE, added nodes and edges to the graph and executed cypher queries to extract important data from the graph. This is just a simple illustration of how AGE can be effectively utilized for data acquisition and extraction in a network. Next up, we would be looking at how to visualize graphs and the results from queries using AGE Viewer.

For more information on Apache AGE, visit:
AGE website
AGE GitHub

The Graph Analytics Revolution: Understanding the Dynamic Tool Driving Modern Technology

Tito Osadebey — Wed, 12 Apr 2023 13:39:46 +0000

Discovering how graphs function and their relevance in different fields requires an examination of graph analytics. Graphs are essential tools with countless practical applications such as social network analysis, cybersecurity concerns, and predictive analytics. This piece aims to reveal the intricacies behind this dynamic tool while highlighting its importance amid latest technological advancements.

What is a Graph?
A Graph is a mathematical structure that is used to model various types of relationships in different systems. In simple terms, it is a collection of nodes or vertices connected by edges.

The nodes or vertices (representing the entities) are connected by edges (representing relationships between those entities). Nodes can be people, groups, places, organisations, products, bank accounts, or devices. While examples of edges between nodes, include friendships, network connections, hyperlinks, roads, routes, wires, phone calls, emails, tweets, “likes,” or payments.

Edges can have a one-way direction arrow to represent a relationship from one node to another, for example, if David “purchased” an item from Teke and Amos "reacted" to Lucky's Instagram post.

However, edges can also be non-directional, like Marcos and Tito being connections on LinkedIn and Janet Jackson being a sibling to Michael Jackson.

Why Graphs?

Graph analytics can be used to determine the strength and direction of relationships between objects in a graph, such as analyzing relationships in social networks, cyber threat detection, and identifying the people most likely to buy a product based on shared preferences.

Graph analytics has been very effective in achieving the following:

Detect financial crimes such as money laundering
Identify fraudulent transactions and activities
Perform influencer analysis in social network communities
Do recommendation analysis from customers ratings or purchases
Identify weaknesses in power grids, water grids, and transportation networks
Optimize routes in the airlines, retail, and manufacturing industries
Understanding how influence works so marketers can target the people who are most likely to create word-of-mouth awareness for their products
Helping political campaigns and political scientists better understand the factors that contribute to information virality and the dissemination of fake news.

Conclusion
The application of graph analytics is ever-present and has proved powerful in a variety of fields, including cyber threat detection and social networks. Graph analysis enables us to represent multi-dimensional structures with ease while also simplifying the interpretation process thereof. This provides an array of insights that can be applied using Apache AGE by data scientists or business analysts among others, given their potential to inform better decision-making processes.

For more information on Apache AGE, visit:
AGE website
AGE GitHub

Getting Started with Apache AGE: A Comprehensive Guide (Part 1)

Tito Osadebey — Wed, 05 Apr 2023 08:23:53 +0000

Introduction

In this guide, we will walk through everything you need to know to get started with Apache AGE. Whether you’re an experienced graph database user or you’re just starting out, this guide will provide you with a detailed process to working with Apache AGE. In this first part, we’ll cover the introduction and installation of Apache AGE. By the end of this tutorial, you should have a deep understanding of Apache AGE and have it installed.

What is Apache AGE?

Apache AGE is an open-source graph database management system that provides a powerful and scalable solution for storing, managing and analyzing large-scale graph data. It is built as an extension of PostgreSQL and supports complex graph queries and provides fast query response times, making it an excellent choice over traditional relational database management systems. With Apache AGE, users can gain deeper insights into data and make more informed decisions. Apache AGE is a tool you won’t want to overlook as a developer, data scientist or graph expert.

Setting up and Installation

Apache AGE is built as an extension to PostgreSQl. Hence, you should have either PostgreSQL 11 or 12 installed on your device (AGE is only compatible with these versions as of the time of this post).
For a step-by-step guide to install the required version, click here.
With PostgreSQL installed, follow the steps below to install AGE:

1. Clone the AGE repository in the same directory where you installed PostgreSQL.

git clone https://github.com/apache/age.git

2. Move into the repository and change the branch to the latest version which is v1.1.0.

cd age
git checkout release/PG12/1.1.0

3. Make PG_CONFIG an environment variable and install.

export PG_CONFIG=/usr/local/pgsql-12/bin/pg_config

sudo make PG_CONFIG=/usr/local/pgsql-12/bin/pg_config install

After installation, we initialize a database cluster to set up AGE on PostgreSQL.

initdb age_test

Next, we start a server.

pg_ctl -D age_test -l logfile start

createdb age_testdb

Start up PostgreSQL, create the extension, load the extension and set the search_path.

psql age_testdb

CREATE EXTENSION age;
LOAD ‘age’;
SET search_path = ag_catalog, “$user”, public;

After initializing a DB, the AGE extension has to be loaded to start using it. This can be set in the postgresql.conf located in the DB directory which will make AGE load automatically and also set the search_path.
To view installed extensions:

\dx

If age is listed, then it has been successfully installed.

Conclusion

Setting up Apache AGE is just the first step in unlocking the power of graph data analytics. With Apache AGE, we can create complex graphs, store, manage, and query large-scale graph data with ease. As we move forward in this guide, we will explore the advanced features of Apache AGE and how to use this powerful system efficiently. In the next part, we would look at creating and analyzing graphs.

References
Apache AGE website
Apache AGE project

Understanding The Process and Memory Architecture of PostgreSQL

Tito Osadebey — Tue, 21 Mar 2023 09:58:28 +0000

In my last article, I covered the steps to install PostgreSQL easily and stated that I would also share steps to install AGE. However, I think it is important to share what happens in the background while running PostgreSQL before installing AGE. This post covers the summary of the process and memory architecture of PostgreSQL.

PROCESS ARCHITECTURE
A PostgreSQL server is a series of various processes cooperatively managing a database cluster (recall that to initialize a cluster, initdb cluster_name is executed).
The server contains the following processes which will be explained in detail:

Postgres server process
Backend process
Background process
Replication associated process
Background worker process.

Only the first three types are covered here with more emphasis on the first two.

Postgres Server Process (earlier called the ‘postmaster’) is the parent process related to the management of the database cluster. It is started by executing pg_ctl -D dbname -l logfile start. It starts various processes except the backend process after allocating a shared memory area in memory. It waits for requests from clients to connect and starts the backend process when receiving that request. The server’s default port is 5432 and this is the only port it listens to.
Backend Processes (known as ‘postgres’) is started by the postgres server process which was earlier mentioned. This process handles all queries by a connected client. It only operates on one database; the client has to specify the database when connecting to a server like so pg_ctl -D dbname -l logfile start.
Background Processes - this process is made up of some functions that are quite complicated and depends on specific features.

MEMORY ARCHITECTURE
This can be classified into two categories:

Local memory area
Shared memory area

Local Memory Area - this is allocated by each backend process for processing queries and is divided into sub-areas with fixed or varying sizes. The major sub-areas are work_mem, maintenance_work_mem, and temp_buffers.
Shared Memory Area is automatically allocated when the PostgreSQL server starts. Unlike the local memory area with fixed and varying sizes for sub-areas, the sizes for sub-areas of the shared memory area are fixed. The major sub-areas are shared buffer pool, WAL (Write Ahead Logging) buffer, and commit log.

CONCLUSION
Understanding the working processes of the software platform that one is utilizing is highly essential, as it facilitates debugging and efficient utilization. To delve deeper into the architecture of PostgreSQL, please refer to the resources section below for information on the Internals of PostgreSQL.

RESOURCES
The internals of PostgreSQL
Apache AGE website
Apache AGE project

Easy Guide to Install PostgreSQL from Source code on Windows

Tito Osadebey — Thu, 16 Mar 2023 09:44:57 +0000

As promised in my earlier post, I stated that I would be sharing a lot about my internship experience, AGE project and how to effectively utilize it. Firstly, this post covers the installation of PostgreSQL which is the foundation on which AGE is built and to be used.

WHAT IS POSTGRESQL?
PostgreSQL is a very powerful open-source relational database management system (RDBMS) known for its robustness, reliability, and extensibility. It supports a wide range of SQL features and data types and provides advanced functionality such as support for geographical information systems, full-text search, and JSON data. It also supports transaction processing, multi-version concurrency control, and can be run on a variety of operating systems, including Windows, Linux, and macOS.
These characteristics has made it a popular choice for a wide range of applications, from small-scale projects to large enterprise systems. For more information, click here.

INSTALLATION
Apache AGE cannot be installed on Windows yet but it is still possible to use it by installing Windows Subsystem for Linux (WSL). PostgreSQL can be installed on Windows but for this setup, it is advisable to install both PostgreSQL and AGE through WSL.

1. Installing WSL
Open the command prompt and enter the following commands.

wsl –install
wsl –update

This will install the Linux system. After the installation of WSL, you can make use of it in the command prompt by entering the command.

bash

Upon running for the first time, a username and password will be requested.

2. Installing PostgreSQL
You should install either versions 11 or 12 of PostgreSQL as they are the versions currently compatible with Apache AGE. To successfully install PostgreSQL, some dependencies are very important and should be within the system.
Install the dependencies.

sudo apt install git libreadline-dev zlib1g-dev bison flex build-essential

Create a directory to clone the PostgreSQL repository.

mkdir postgres-age
cd postgres-age
git clone https://git.postgresql.org/git/postgresql.git

Move into the cloned repository and change the branch to any of the compatible versions (version 12 in this case).

cd postgresql
git checkout REL_12_STABLE

Compile the code by passing the directory where resulting binaries from the compilation will be installed. The compilation process would take some time.

./configure –prefix=/usr/local/pgsql-12 
make

When compilation is completed, add permissions to the binaries directory and then install PostgreSQL.

sudo mkdir /usr/local/pgsql-12
sudo chown [user] /usr/local/pgsql-12
make install

Add the path to the PostgreSQL’s bin and data directories to environment variables.

export PATH=/usr/local/pgsql-12/bin/:$PATH
export PGDATA=/usr/local/pgsql-12/bin/data

PostgreSQL is successfully installed. To make use of it, a cluster has to be initialized first using the following command:

initdb

The above command initializes a default cluster. To initialize another cluster, you would have to add the name after the command, for example:

initdb test

After initializing a cluster, start the server and create a database.

pg_ctl -D test –l logfile start
createdb test

To execute the above, you must have moved into the bin directory where PostgreSQL was installed.

Start PostgreSQL with the following command.

psql test

To exit PostgreSQL.

\q

Stop the server.

pg_ctl -D test –l logfile stop

To learn more about the installation of PostgreSQL 12, you can click here

CONCLUSION
So that’s how to successfully install the compatible version of PostgreSQL for Apache AGE. If you have challenges or questions relating to the installation process, you can reach out to me.
In the next post, I will show you easy steps on how to install AGE. I had some challenges doing that and I would not want anyone else to face that.

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

Week 1 as a Software Engineering Intern

Tito Osadebey — Thu, 09 Mar 2023 10:39:23 +0000

This is going to be a lengthy journey filled with tales, so I implore you to stay with me and follow along.

Back in December 2022, I was in the process of job hunting when I stumbled upon an internship opportunity at Bitnine Global Inc.. Despite facing location challenges throughout my job search, I persevered and applied for the position, thanks to having the requisite skills.

After a while, I received an email notifying me of a coding test for the position I applied for and I was quite anxious on what to expect and how to revise for this test. However, I refused to let fear consume me and completed the test, quite challenging but I loved it.

Some weeks later, I received another email congratulating me on my successful completion of the coding test and inviting me to the next stage, which was an interview. I was understandably nervous, but I reached out to some already serving interns for advice, which proved to be invaluable and ultimately helped me secure the position.

Upon starting the internship, I received a link to the onboarding process, which was impressive. My Operations Manager has been incredibly supportive, and I truly appreciate that about him. However, when I was assigned to the AGE project, I knew it would be a an awesome experience and I was up for it and ready to embrace the opportunity.

After the meeting, I spent a significant amount of time installing the required dependencies and software, conducting research, watching videos, and reading. The information was overwhelming, but I enjoyed being very active.

When I successfully completed the installation, I tried some
examples out and I was amazed by the beauty of Apache AGE and AGE VIEWER. The software provided an incredible way to study, query, relate with, and visualize data. I'm still poring over the documentation, taking my time to fully understand everything about the project because I believe it will revolutionize how data is utilized. I'm excited to see how it will be implemented in the AI and Robotics space.

That's all for week one though, I'll be posting regularly about this experience and tips on how to utilize Apache AGE. Don't forget to follow me.

For more information about the project, visit:
Apache AGE
GitHub