DEV Community: Muhammad Farooq

How Apache AGE Works on Top of PostgreSQL

Muhammad Farooq — Sun, 27 Aug 2023 11:37:46 +0000

Introduction

Apache AGE is a PostgreSQL extension that provides graph database functionality. The goal of Apache AGE is to enable Postgres users to gain access to graph query modeling in Postgres, existing relational model. In this blogpost, I will explain how Apache AGE works on top of PostgreSQL and what benefits it brings to the users.

What is a Graph Database?

A graph database is a type of database that stores data as nodes and edges, where nodes represent entities and edges represent relationships between them. A graph database allows users to query and analyze complex connected data using graph algorithms and traversal patterns. Graph databases are useful for applications that deal with social networks, recommendation systems, fraud detection, knowledge graphs, and more.

Why Use Apache AGE?

Apache AGE is an extension for PostgreSQL that allows users to use graph data models within the database. It is built on top of the Apache Arrow format, which provides a high-performance, in-memory data structure for data processing. Apache AGE supports openCypher, one of the most popular graph query languages today, as well as SQL, the standard relational query language. Users can perform hybrid queries that combine both graph and relational data in a single query.

Some of the benefits of using Apache AGE are:

Users can leverage the power and features of PostgreSQL
Users can use existing relational data without going through migration or transformation. They can simply create graph views on top of the tables and query them as graphs.
Users can benefit from the performance and scalability of Apache Arrow, which enables fast data transfer and computation between different systems and languages.
Users can enjoy the flexibility and expressiveness of openCypher, which supports various graph operations such as pattern matching, aggregation, projection, filtering, ordering, and more.

How Does Apache AGE Work?

Apache AGE works as a plugin for PostgreSQL that extends its functionality with graph features. It consists of three main components: the parser, the executor, and the storage engine.

The parser:
It is responsible for parsing the user's queries and converting them into an internal representation that can be executed by the executor.
The executor:
It is responsible for executing the queries and performing the graph operations. It uses Apache Arrow to store and manipulate the data in memory.
The storage engine:
It is responsible for storing and retrieving the data from the underlying PostgreSQL tables. It uses a custom data type called agtype to store the graph data as JSONB objects.

The following diagram illustrates how Apache AGE works on top of PostgreSQL:

How to install Apache AGE Extension?

To use Apache AGE, users need to install it as an extension for PostgreSQL. They can download the source code or binary packages from the official website or the GitHub repository.

Conclusion

Apache AGE is a PostgreSQL extension that provides graph database functionality. It allows users to use graph data models within the existing relational database. It supports openCypher and SQL.
It works as a plugin for PostgreSQL that extends its functionality with graph features. It consists of three main components: the parser, the executor, and the storage engine.

Integration of Apache AGE and Citus to Build a Scalable Graph Database on PostgreSQL

Muhammad Farooq — Wed, 23 Aug 2023 17:27:42 +0000

Graph Database

Graph databases are becoming increasingly popular for applications that need to store and analyze complex and interconnected data, such as social networks, recommendation systems, or knowledge graphs. Graph databases allow you to model your data as nodes and edges, and query them using graph algorithms and languages.

However, most graph databases are separate from relational databases, which means that you need to maintain two different systems, migrate your data, and integrate your queries. Moreover, most graph databases are not designed to scale horizontally, which limits their performance and capacity.

What if you could use PostgreSQL as a graph database, and also scale it out across multiple nodes? This is where Apache AGE and Citus come in.

What is Apache AGE?

Apache AGE is a graph database extension for PostgreSQL that allows you to store, query, and analyze graph data in a relational database. Graph data is composed of nodes and edges that represent entities and relationships. With Apache AGE, you can use openCypher, a popular graph query language, to manipulate and explore graph data in PostgreSQL. You can also use SQL to query both graph and relational data in a hybrid way.

Some of the benefits of using Apache AGE are:

You can leverage the power and reliability of PostgreSQL as a relational database system, while also gaining access to graph functionality.
You can use existing PostgreSQL tools and libraries to work with graph data, without needing to migrate or integrate with a separate graph database.
You can perform fast and efficient graph analysis using various algorithms and functions provided by Apache AGE.
You can visualize and interact with graph data using Apache AGE Viewer, a web user interface for Apache AGE.

If you want to learn more about Apache AGE, you can visit its official website and its GitHub repository.

What is Citus?

Citus is a PostgreSQL extension that transforms Postgres into a distributed database—so you can achieve high performance at any scale. With Citus, you extend your PostgreSQL database with new superpowers:

Distributed tables are sharded across a cluster of PostgreSQL nodes to combine their CPU, memory, storage and I/O capacity.
References tables are replicated to all nodes for joins and foreign keys from distributed tables and maximum read performance.
Distributed query engine routes and parallelizes SELECT, DML, and other operations on distributed tables across the cluster.
Columnar storage compresses data, speeds up scans, and supports fast projections, both on regular and distributed tables.

Advantages of using Apache AGE and Citus Together?

By combining Apache AGE and Citus, you can build a scalable graph database on PostgreSQL that can handle large volumes of complex and interconnected data. You can shard your graph data across multiple nodes using Citus, and query it using openCypher or SQL using Apache AGE. You can also join your graph data with your relational data using foreign keys or SQL joins.

To use Apache AGE and Citus together, you need to install both extensions on your PostgreSQL cluster.

But this may not work.

Apache AGE team is working on a new project that is based on integration of Apache AGE and Citus.

Conclusion

In this blog post, I introduced Apache AGE and Citus to build a scalable graph database on PostgreSQL. and how Apache AGE and Citus can work together.

We hope that this blog post was helpful and informative for you. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!

How to Control Autovacuum Frequency in PostgreSQL

Muhammad Farooq — Wed, 23 Aug 2023 15:13:00 +0000

PostgreSQL

PostgreSQL is a powerful and reliable database system that offers many features and benefits. However, it also has some challenges and drawbacks, such as the table bloat problem. Table bloat occurs when the space occupied by a table or an index is larger than the actual data size. This can affect the performance and efficiency of the database, as well as increase the backup and restore time.

One of the main causes of table bloat is the accumulation of dead tuples. Dead tuples are rows that have been deleted or updated, but are still visible to concurrent transactions. PostgreSQL uses a mechanism called MVCC (Multi-Version Concurrency Control) to ensure transaction isolation and consistency. MVCC allows each transaction to see a snapshot of the database at a certain point in time, without locking the rows or tables. This means that old versions of rows are not immediately removed, but are marked as dead and invisible to new transactions.

To reclaim the space occupied by dead tuples, PostgreSQL runs a process called vacuum. Vacuum removes dead tuples from the tables and indexes, and marks the space as free for reuse. Vacuum also updates the visibility map, which tracks which pages of a table contain only visible tuples. This helps to speed up index-only scans, which can avoid reading the table pages if the visibility map indicates that they are not needed.

Autovacuum

PostgreSQL has an automatic vacuum daemon called autovacuum, which runs in the background and performs vacuum on tables that need it. Autovacuum is triggered by various factors, such as the number of dead tuples, the age of the transaction ID, and the size of the table. Autovacuum also performs analyze, which updates the statistics used by the query planner to choose the best execution plan.

However, sometimes autovacuum may not run frequently enough for some tables, especially those with a large number of tuples and a high update or delete rate. This can lead to excessive table bloat and poor query performance. In this blog post, we will show you how to control the frequency of autovacuum for specific tables using storage parameters.

Storage Parameters

Storage parameters are options that can be set for each table or index to control their physical storage characteristics. Some of these parameters affect how autovacuum behaves for a given relation. The two parameters that we will focus on are:

autovacuum_vacuum_threshold: The minimum number of dead tuples in a table before autovacuum will issue a VACUUM command on it. The default value is 50.
autovacuum_vacuum_scale_factor: A fraction of the total number of tuples in a table that will be added to autovacuum_vacuum_threshold to determine whether autovacuum should issue a VACUUM command on it. The default value is 0.2.

The formula for calculating when autovacuum will run on a table is:

(the number of dead tuples) > autovacuum_vacuum_threshold + autovacuum_vacuum_scale_factor * (the number of tuples)

For example, if a table has 100,000 tuples and 20,000 dead tuples, autovacuum will run on it when:

20,000 > 50 + 0.2 * 100,000

which simplifies to:

20,000 > 20,050

which is false, so autovacuum will not run on this table.

However, if we change the storage parameters for this table to:

autovacuum_vacuum_threshold = 1000
autovacuum_vacuum_scale_factor = 0

then autovacuum will run on it when:

20,000 > 1000 + 0 * 100,000

which simplifies to:

20,000 > 1000

which is true, so autovacuum will run on this table.

By adjusting these parameters, we can make autovacuum more aggressive or more conservative for specific tables, depending on our needs and preferences.

Example

Let's see how this works in practice using an example. We will use the pgbench_accounts table from the pgbench benchmark tool. This table has 100,000 rows and is frequently updated by pgbench transactions.

We can check the current storage parameters for this table using the \d+ command in psql:

postgres=# \d+ pgbench_accounts

Table "public.pgbench_accounts"

   Column   |     Type      | Collation | Nullable | Default | Storage | Stats target | Description 
------------+---------------+-----------+----------+---------+---------+--------------+-------------
 aid        | integer       |           | not null |         | plain   |              | 
 bid        | integer       |           |          |         | plain   |              | 
 abalance   | integer       |           |          |         | plain   |              | 
 filler     | character(84) |           |          |         | extended|              | 
Indexes:
    "pgbench_accounts_pkey" PRIMARY KEY, btree (aid)
    "pgbench_accounts_bid_index" btree (bid)
Options: autovacuum_vacuum_threshold=1000, autovacuum_vacuum_scale_factor=0

We can see that the table has the storage parameters that we want to use for this example. If we want to change them, we can use the ALTER TABLE command:

postgres=# ALTER TABLE pgbench_accounts SET (autovacuum_vacuum_threshold = 1000);
ALTER TABLE
postgres=# ALTER TABLE pgbench_accounts SET (autovacuum_vacuum_scale_factor = 0.0);
ALTER TABLE

Now, let's generate some dead tuples by updating some rows in the table:

postgres=# update pgbench_accounts set abalance = 1 where aid < 1002;
UPDATE 1001

We can check the number of dead tuples and the last autovacuum time for this table using the pg_stat_all_tables view:

postgres=# SELECT relname, n_dead_tup, last_autovacuum FROM pg_stat_all_tables WHERE relname = 'pgbench_accounts';
     relname      | n_dead_tup |        last_autovacuum        
------------------+------------+-------------------------------
 pgbench_accounts |       1001 | 2023-07-01 00:32:23.627931+09
(1 row)

We can see that the table has 1001 dead tuples and the last autovacuum was at 00:32:23. If we wait for a few minutes, we can see that autovacuum runs again on this table:


postgres=# SELECT relname, n_dead_tup, last_autovacuum FROM pg_stat_all_tables WHERE relname = 'pgbench_accounts';
     relname      | n_dead_tup |        last_autovacuum        
------------------+------------+-------------------------------
 pgbench_accounts |          0 | 2023-07-01 00:43:24.498598+09
(1 row)

We can see that the number of dead tuples is now zero and the last autovacuum was at 00:43:24. This means that autovacuum ran on this table as soon as it reached our set threshold of 1000 dead tuples.

Apache AGE:

Conclusion

In this blog post, we learned how to control the frequency of autovacuum for specific tables using storage parameters. We saw how to adjust the autovacuum_vacuum_threshold and autovacuum_vacuum_scale_factor parameters to make autovacuum more aggressive or more conservative for a given table. We also saw an example of how this works in practice using the pgbench_accounts table from the pgbench benchmark tool.

We hope that this blog post was helpful and informative for you. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!

Features of PEM on top of PgAdmin

Muhammad Farooq — Tue, 15 Aug 2023 18:33:51 +0000

Introduction

PEM stands for Postgres Enterprise Manager, which is a comprehensive management tool for PostgreSQL and EDB Postgres Advanced Server1. PEM is built upon pgAdmin, which is the most popular open source administration and development platform for PostgreSQL.

PEM Console

PEM Console is a desktop application that provides a graphical user interface for PEM. It is built upon pgAdmin, which means that it inherits all the features of pgAdmin plus the additional features of PEM. PEM Console allows you to access and manage your PostgreSQL or EDB Postgres servers and databases from your local machine, without the need of a web browser or a network connection.

PEM Console is compatible with Windows, Linux, and Mac OS X platforms, You need to register the PEM agent with the PEM server using the pemworker utility. Once you have done that, you can launch PEM Console and log in with your username and password. You can then see your servers and databases in the browser panel, and start managing them as you wish.

PEM REST API

PEM REST API is a web service that allows you to interact with PEM programmatically using HTTP requests and responses. It exposes various endpoints for performing operations such as retrieving information, creating and modifying objects, executing commands, running queries, generating reports, and accessing other tools. You can use PEM REST API to automate tasks, integrate with other applications, or create custom solutions for your PostgreSQL or EDB Postgres servers and databases.

PEM REST API is based on the OpenAPI specification, You can use any programming language or tool that supports HTTP requests to communicate with PEM REST API.

To use PEM REST API, you need to authenticate yourself with your username and password using the Basic Authentication scheme. You also need to specify the Content-Type header as application/json for all requests that have a body. You can then send HTTP requests to the endpoints of PEM REST API.

PEM CLI

PEM CLI is a command-line interface that allows you to interact with PEM using commands and arguments. It is a wrapper around the PEM REST API, which means that it uses the same endpoints and parameters as the PEM REST API. PEM CLI allows you to perform tasks such as retrieving information, creating and modifying objects, executing commands, running queries, generating reports, and accessing other tools from your terminal or shell. You can use PEM CLI to automate tasks, integrate with other scripts or programs, or create custom solutions for your PostgreSQL or EDB Postgres servers and databases.

PEM CLI is available for Windows, Linux, and Mac OS X platforms, you can launch PEM CLI from your terminal or shell by typing pem followed by a command name and its arguments. You can also use pem --help or pem <command> --help to see the usage and options of each command.

Features Extended by PEM:

Monitoring the performance, health, and activity of your PostgreSQL or EDB Postgres servers and databases in real time. You can view metrics such as CPU, memory, disk, network, sessions, locks, transactions, queries, replication, backups, logs, and alerts.
Allow You to create custom dashboards and charts to visualize the data that matters to you.
Setting up notifications and actions based on predefined or custom rules and thresholds. You can receive alerts via email, SMS, or SNMP when something goes wrong or needs your attention.
Help you to optimize the performance of your PostgreSQL or EDB Postgres servers and databases by providing recommendations and tools for tuning various parameters and settings.
Assist you to protect your data and ensure its availability by offering backup and recovery solutions for your PostgreSQL or EDB Postgres servers and databases. You can schedule full or incremental backups, restore data from backups or point-in-time recovery (PITR), verify backup integrity, encrypt backup files, compress backup size, and manage backup storage.
Allow you to analyze the performance of your SQL queries and statements by providing tools for profiling and debugging. You can capture and view the execution plans of your queries and identify slow or problematic queries.
Enable you to manage your team members and their access to your PostgreSQL or EDB Postgres servers and databases by providing features for role-based security and auditing.

Apache AGE

Please Visit Apache AGE which is A Graph Extension to very popular Database PostgreSQL, and visit AGE's Github repository if you want to contribute.

Conclusion

In this post, I have shown you some of the extra features of PEM that make it stand out from other enterprise managers. These features are:

PEM Console: A desktop application that provides a graphical user interface for PEM.
PEM REST API: A web service that allows you to interact with PEM programmatically using HTTP requests and responses.
PEM CLI: A command-line interface that allows you to interact with PEM using commands and arguments.

These features allow you to access and manage your PostgreSQL or EDB Postgres servers and databases from different platforms and interfaces according to your preference and convenience.
They also enable you to automate tasks, integrate with other applications, or create custom solutions for your PostgreSQL or EDB Postgres servers and databases.
Some
PEM also extends the functionality of pgAdmin by providing features such as monitoring, alerting, tuning, backup and recovery, SQL profiling, team management, and auditing

I hope you have found this post informative and helpful. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!

Enterprise managers built on top of pgAdmin

Muhammad Farooq — Tue, 15 Aug 2023 17:50:51 +0000

What is pgAdmin?

pgAdmin is the most popular and feature rich Open Source administration and development platform for PostgreSQL, the most advanced Open Source database in the world.
PgAdmin allows you to manage your PostgreSQL or EDB Postgres databases from a graphical user interface or a web browser.

pgAdmin is designed to be easy to use for beginners and experts alike. It supports all the features of PostgreSQL from version 9.5 to 14, as well as *EDB Postgres Advanced Server from version 9.6 to 13. *

pgAdmin is available for Windows, Linux, and Mac OS X platforms, and can be downloaded for free from the official website.

What are enterprise managers?

Enterprise managers are comprehensive management tools that extend the functionality of pgAdmin by providing additional features that are essential for enterprise-level database administration and development.

Some of these features include:

Monitoring the performance, health, and activity of your PostgreSQL or EDB Postgres servers and databases in real time. You can view metrics such as CPU, memory, disk, network, sessions, locks, transactions, queries, replication, backups, logs, and alerts.
Allow You to create custom dashboards and charts to visualize the data that matters to you.
Setting up notifications and actions based on predefined or custom rules and thresholds. You can receive alerts via email, SMS, or SNMP when something goes wrong or needs your attention.
Help you to optimize the performance of your PostgreSQL or EDB Postgres servers and databases by providing recommendations and tools for tuning various parameters and settings.
Assist you to protect your data and ensure its availability by offering backup and recovery solutions for your PostgreSQL or EDB Postgres servers and databases. You can schedule full or incremental backups, restore data from backups or point-in-time recovery (PITR), verify backup integrity, encrypt backup files, compress backup size, and manage backup storage.
Allow you to analyze the performance of your SQL queries and statements by providing tools for profiling and debugging. You can capture and view the execution plans of your queries and identify slow or problematic queries.
Enable you to manage your team members and their access to your PostgreSQL or EDB Postgres servers and databases by providing features for role-based security and auditing.

How to get started with enterprise managers?

One of the most popular enterprise managers for PostgreSQL and EDB Postgres is Postgres Enterprise Manager (PEM), which is developed by EnterpriseDB, which is the leading provider of enterprise-class products and services based on PostgreSQL.
PEM is built upon pgAdmin, which means that it inherits all the features of PgAdmin plus the additional features mentioned above.
PEM is compatible with all versions of PgAdmin

To get started with PEM, you need to download the installer from the official website or use a package manager such as yum or apt-get if you are using Linux. You need to install two components: the PEM server and the PEM agent. The PEM server is the central component that manages the communication between the PEM agents and the web interface. The PEM agent is the component that collects the data from the PostgreSQL or EDB Postgres servers and databases that you want to monitor and manage. You need to install the PEM server on one machine, and the PEM agent on each machine that hosts a PostgreSQL or EDB Postgres server or database. You can also install the PEM agent on the same machine as the PEM server if you want to monitor and manage the local server or database.

After installing the PEM server and the PEM agent, you need to register the PEM agent with the PEM server using the pemworker utility.
This utility allows you to specify the connection details of the PEM agent and the PostgreSQL or EDB Postgres server or database that you want to monitor and manage. You can also use this utility to update, unregister, or remove the PEM agent.

Once you have registered the PEM agent with the PEM server, you can access the web interface of PEM by opening a browser and navigating to the URL of the PEM server. The default URL is http://localhost:8080/pem. You need to log in with your username and password, which are admin and admin by default. You can change them later in the preferences menu.

The web interface of PEM consists of three main areas:

The dashboard:
It displays an overview of your PostgreSQL or EDB Postgres servers and databases, as well as their status, metrics, alerts, and charts.
The browser:
It allows you to navigate through your servers and databases, as well as their objects and properties.
The workspace:
It allows you to perform various tasks such as creating and editing objects, running SQL queries and scripts, viewing data and query plans, generating reports and charts, and accessing other tools such as monitoring, alerting, tuning, backup and recovery, SQL profiling, team management, and auditing.

You can use the web interface of PEM to monitor and manage your PostgreSQL or EDB Postgres servers and databases as you wish. You can also use pgAdmin as a standalone application or a plugin for PEM if you prefer a graphical user interface over a web browser. You can switch between pgAdmin and PEM by clicking on the pgAdmin or PEM icons in the toolbar.

Apache AGE

Please Visit Apache AGE which is A Graph Extension to very popular Database PostgreSQL, and visit AGE's Github repository if you want to contribute.

Conclusion

In this post, I have explained what pgAdmin and enterprise managers are, why they are useful for PostgreSQL and EDB Postgres users, and how you can get started with them, in last I have introduced very powerful Graph Database AGE.

I hope you have found this post informative and helpful.

If you have any questions or feedback, please feel free to leave a comment below.

Thank you for Reading

When to use RDB or GDB?

Muhammad Farooq — Mon, 31 Jul 2023 18:51:36 +0000

See the tutorial: Advantages of Relational DB, Graph DB, and RGDB

The following details will help you decide when to choose which database over the other. To maintain the existing system or to further advance the system depends entirely on your choice.

Fast analysis or Log management

The graph DB is suitable for predictive analytics and fraud detection because it easily finds and identifies hidden patterns that are difficult to find with a naked eye. Since it is generally optimized for data inquiry and analysis, it is an excellent choice if these are important traits to consider for the project.
However, if there is no need for data analysis and the purpose of the project is to simply record data in logs, the relational DB may be a better choice.

Depth of relationship

The graph DB is worth considering when there are numerous connections or patterns within the stored data and when meaningful insights need to be returned. It efficiently finds hidden patterns, providing additional factors to aid in decision-making. Converting structured, semi-structured, and unstructured data into a graph DB can broaden the perspective on data understanding.

The relational DB is more suitable than the graph DB if the project is more transaction-oriented. Sometimes it is better to simply store and manage data rather than trying to understand the relationship between data.

Consistency of data model

Finally, the graph DB is recommended when the data model needs to be changed frequently. The graph DB is schema-less, so its flexibility in adding properties is well known. Additional attributes can be added in order to understand the depth of analysis or when the attribute of certain data is not strictly defined (eg. unstructured data such as video or photos).

On the other hand, table data of the relational DB boasts consistency, which becomes its advantage. When storing personal information such as name, date of birth, location, etc., the relational DB may be more efficient due to not having to change new fields or data often.

RGDB: a multi-model that can use both RDB & GDB

At present, finding hidden insights from a vast amount of data is becoming a trend as it could mean increasing corporate competitiveness. As such, the number of cases taking advantage of the efficiency of both the relational and graph databases is increasing.
For example, let’s say a bank has decided to build an AI management system using data from a relational DB that has been used for monitoring voice phishing. This bank has millions of accounts with transaction history and the detailed transactions between accounts and accident reports must all be recorded in a table format. The storage and management of big data can be maintained with the existing management system just fine, but among the data, some parts may require pattern tracking or deep analysis (eg. transaction info between accounts) for further insights. In that case, the said data can be transferred to the graph DB for analysis and the analyst will be able to find, for example, fraudulent activities like abnormal transactions.

In fact, many of the current big data platforms implemented with the graph DB also maintain relational DB for data management. Each DB working together may be able to bring out a synergy that complements each other’s strengths and weaknesses.

The purpose is the key

As there are always two sides to everything, the graph DB, despite being the latest database technology, is not a perfect solution to all problems. The same can be said of relational DBs that many companies have been using for a long time. Depending on the need of the company, either one of them or both may be required.

The main reason for choosing the graph DB is to analyze data relationships. As for relational DB, it is to accurately aggregate numerous data. If you want to apply both for different purposes and increase efficiency at the same time, you may want to consider a multi-model database with a mix of the two. For example, accurate management of existing data can be done with a relational DB and data analysis with a graph DB. This is one of the ways to gain new insights while maintaining the existing data management paradigm.

Before deciding which database to choose, it would be wise to consider what characteristics your data have or what you want to achieve from the data. Seeking a tip from an expert consultant regarding the decision may also be a good choice. In the end, the choice is yours to decide.

Visit Apache AGE:

Advantages of Relational DB, Graph DB, and RGDB

Muhammad Farooq — Mon, 31 Jul 2023 18:39:59 +0000

Introduction to Relational DB & Graph DB

The relational DB and graph DB are the most popular databases known for their own respective strengths and unique characteristics. They are no more a subject of competition because one is not superior to the other.

The use of relational DB and graph DB depends on the characteristics and purposes of the data. The table structure of a relational DB is suitable for storing records of general information or uncomplicated relationships, which is why relational DBs are generally applied in accounting or bank cash transactions.

Graph DB, on the other hand, is most effective for relationship-oriented analysis of complex data. This helps data experts spot unexpected connection patterns. The best-known use cases for graph DBs include social media analytics, fraud detection, and real-time recommendation engines. Mapping relationships between data also has the advantage of being easily conveyed via separate visualization tools.

The two databases can offer different pros and cons in how they structure their relationships. NoSQL, a category in which the graph DB belongs, is an abbreviation of “Not Only SQL”, which means it does not replace the SQL of the relational DB but embraces it. The synergy effect of the graph DB optimized for data utilization and analysis along with the existing system brings new insights and reinforces decision-making for business processes.

It is necessary to understand the differences between the relational DB and graph DB before applying either one of them in a project. As mentioned above, the use of each DB depends on the purpose of use.

Relational Database

A relational DB stores data in tables. A table is defined by having columns and rows. Each row is identified by a unique key that links to a row in another table, and each table contains a primary key that identifies information found within the table. Since they can be divided into the same exact schema, the relational DB is able to manage data accurately.

Additionally, the relational DB is divided into a logical structure of tables, a structure of physical storage. This allows data experts to make changes to the physical data structure without affecting the logical structure.

The relational DB requires additional tables containing information from existing tables to model the relationship with other tables. As shown in the image below, you can see a network of tables linked to analyze the products the customer has purchased.

Graph Database

While the relational DB can only manage structured data, the NoSQL databases are able to analyze semi-structured and unstructured data as well. These data are generally schema-less, hence the reason why relational DB struggles to manage them.

According to the trend chart from DB-Engines.com, the graph database is the most popular database in the NoSQL market. It is showing overwhelming growth in the market, which signifies the recognition of its future value. Gartner, one of the global market research institutes, predicts that by 2025, 80% of companies around the world will use the graph DB.

The basic components of a graph DB are as follows:

Node: the main object of the graph. Similar to ‘row’ in RDB

Edge: expresses the relationship between objects. Similar to the ‘foreign key’ of RDB

Label: a property that groups similar nodes together

Properties: keys/values stored within a node or edge (relationship)

In the social network graph shown above, everyone is represented by a single node labeled as Person. This node contains properties such as name, gender, location, and email. Relationships (edge) between people in that network are specified as FRIENDS_WITH with a time period of their friendship included as a property as well. A person node is also connected with a location node with an edge named, LIVES_IN.

The image above is a simple example, but it shows the general idea of how a relationship of data is expressed in the graph DB. Adding properties to some nodes can be done easily in a graph DB, so it gives data experts more flexibility when it comes to data modeling. The graph DB is able to extract values and retrieve meaningful insights for the analysts.

Reference

Bitnine Global Inc

Visit Bitnine and Apache AGE

Explainable AI and Graph Database

Muhammad Farooq — Mon, 31 Jul 2023 16:56:12 +0000

What is XAI - Explainable AI

Explainable AI is a term that refers to artificial intelligence systems that can provide understandable and transparent explanations for their decisions or predictions.

Explainable AI & Machine Learning & Graph Analytics

With the growing adoption of machine learning, explainable models are becoming a hot industry topic. Predictive models based on traditional neural and deep learning networks are known for their ambiguity on how a particular outcome came to be, whereas an explainable model could by showing some key variables.

Decision Tree - A Classic Example

A classic example of an explainable model is a decision tree. The decision tree generally has a form of a special kind of graph.

Graph Interpretation

Similarly, using graph algorithms or graph features as part of an AI model can easily interpret natural meaning in graph relationships, such as, “customer–(purchases)–>product”.

Advantages of XAI

Explainable AI models have many advantages. For example, if a personalized recommendation model has an explanation or evidence for its outcome, users are more likely to trust and prefer the said model over the standard ones. Graph analytics is also suitable for calculating and displaying evidence by explaining with graph visualization when needed. It may show products of other users with similar interests to you, or products that are similar to products that users have previously purchased on a network of purchased items.

Use of Graph in traditional ML

The graph-based analytics and machine learning are useful not only for customers but also for corporate users. Many companies employ large teams of trained analysts to determine whether a transaction is potentially fraudulent. With the help of a fraud detection system (FDS) powered by graph algorithms, the analysts are able to connect multiple data sources with nodes and edges to visually show potential fraudulent transactions. The graph based FDS is far more effective than existing machine learning models that judge fraud based on scores.

Another example is phone scam prevention. There are millions of calls that occur every day, but only a small percentage of these are malicious scams. When implemented appropriately, the graph technology combined with machine learning can quickly explore the relationship between sender, phone number, and recipient, and develop a model that detects which call is fraudulent.

XAI and Graph Analytics

Explainable AI (& ML) combined with graph analytics is also useful for regulators and auditors. Banks require advanced methods to detect possible money laundering. Many banks are leveraging machine learning to increase detection accuracy, but at the same time, they need to be able to show auditors the process that their systems are working effectively. ML models using graph-based features provide the necessary transparency.

Graph processes large data quickly & efficiently

Machine learning is often computationally demanding, and graph-based machine learning is no exception. As the size of the linked data expands exponentially, a fast computation is required to traverse the data. Even a typical graph database may not be able to handle deep link analysis with large amounts of graph data. This is why we need a graph database that can process large amounts of data quickly and efficiently.

In order to explain the results of personalized recommendations and fraud detection, powerful queries in the graph database must traverse connections in the graph data, and calculations such as filtering and aggregation must be performed to support complex data structures.

Deeplink graph analytics powers the ability to learn graph patterns and supports the next generation of machine learning by providing explainable models. When combined with AI and ML, the graph-powered explainable AI will be a force to be reckoned with and benefit businesses for years to come.

Reference

Bitnine Global Inc

Also Visit Apache AGE

AgensSQL - Bitnine Global Inc

Muhammad Farooq — Sun, 30 Jul 2023 15:43:17 +0000

Introduction

AgensSQL: an integration of Bitnine’s DB technology and PG expertise, is an all-new relational DBMS based on PostgreSQL, with years of expertise and knowledge accumulated through database research and development.

Agens Enterprise Package:

Usability

AEM (Agens Enterprise Manager)

DB Operation/Management (Monitoring Dashboard)
SQL Edit/Execute/Inquiry (HA & Extension Management)

Scalability

AgensSQL Extension Server

AHM (Agens HA Manager)
Load Balancer (Backup/Restore)
Data Sharding

Stability

AgensSQL DB Engine

PostgreSQL 12 (Data Security)

Key Features

Manage your data with Agens Enterprise Package Essential enterprise features such as high availability and sharding are provided

Data Security

Various security features are added to ensure security and stability of data.

High Availability

In the event of main system failure, the standby server minimizes downtime by restoring the system.

Monitoring

Monitoring dashboard views overall status of the DB such as query analysis, operating environment status, database audit, etc.

Data Sharding

Distribute a single dataset across multiple databases, increasing the total storage capacity of the system.

Downloads

Download Section of Bitnine Global

Also Visit Apache AGE

Advanced Tutorial for Cypher (Part 2)

Muhammad Farooq — Sun, 16 Jul 2023 17:56:06 +0000

This Tutorial is extension of The tutorial Advanced Tutorial for Cypher Part (1)

Create Stored Procedure (1)

You can create Stored Procedure as follows:

The fn_array_uniq function enters an array and returns a unique factor.
IMMUTABLE represents the classification of the volatility of the procedure. Has the characteristics of calculating and processing returns as constants.
STRICT returns a null value whenever the argument is null.
The GENERATE_SERIES function takes** (start, stop, step interval)** as input variables and increments and decreases it to the units set in step interval
The ARRAY_LOWER / ARRAY_UPPER function returns the lower/upper limit of the array dimension.

CREATE FUNCTION fn_array_uniq (anyarray)
RETURNS anyarray 
IMMUTABLE STRICT LANGUAGE SQL 
AS 
$$
SELECT ARRAY (
SELECT DISTINCT $1[i] 
FROM GENERATE_SERIES
(ARRAY_LOWER($1,1), ARRAY_UPPER($1,1)) AS g(i));
$$;

Create Stored Procedure (2)

You can create Stored Procedure as follows:

Ids is a function that takes id of the unique vertex as a factor and appends it to the array.
IF [Conditions] Then [True Execution Code] END IF [False Execution Code] Perform execution code when true or false, depending on the conditions.
FOREACH [Execution Code] Performs an execution code with each row as a factor.
LOOP [Repeat Execution Code] END LOOP Repeat the execution code in the Loop section until there is no input.

CREATE FUNCTION ids(vertex[]) RETURNS text[] AS $$
DECLARE
v vertex;    vids text[];
BEGIN
IF $1 IS NULL THEN
RETURN ARRAY[]::text[];
END IF;
FOREACH v IN ARRAY $1 
LOOP        vids = array_append(vids,
id(v)::text);
END LOOP;
vids = vids[2:];    RETURN vids;
END;
$$ LANGUAGE plpgsql;

Check the Fraud Ring

Explore the raid ring with Cypher Query using Stored Procedure.

SELECT cy.path
FROM (match path = (person:person)-[*..]-(person) with path,ids(nodes(path)) as node
    return path,length(fn_array_uniq(node)) as dcnt, length(node) as cnt) cy
WHERE cnt = dcnt

Use the fn_array_uniq function to query the unique Node ID of the Path to be viewed as an array.
Use the Ids function to extract only the Node IDs to consider and count and compare them.
GraphPath that meets the previous conditions among the Paths inquired in the Match clause is printed and inquired.

Explore

Advanced Tutorial for Cypher (Part 1)

Muhammad Farooq — Sat, 15 Jul 2023 19:02:14 +0000

Before reading this blog, you must know the basics of Graph database and Cypher

if you are not familiar with that you can read these blogs

Introduction

To assist in querying graph DB, Stored Procedure can be used using the PL/pgSQL language provided by PostgreSQL.
You can view and handle graph data more efficiently.

AgensGraph

Agens Graph is a multi-model graph database fork of PostgreSQL. PostgreSQL introduced Stored Procedure for better productivity and performance.

Stored Procedures

Stored Procedure uses PL/pgSQL language to provide fast response and convenience, as well as the foundation for extending the functionality of PostgreSQL itself.
Stored Procedure can help query variables used in Cypher queries or convert variables into types.

Basic Procedure Structure

CREATE Function function_name (parameter1 type, parameter2 type)
RETURNS return_type AS
BEGIN
    [CODE]
END;
LANGUAGE language_name;

Procedure can be created with CREATE Function statement,

Specifies the name and factor of the function, the type of factor, and the type of return factor.

Between BEGIN and END, write the code for the function to execute.

Use LANGUAGE to specify the language used in the function instead of language_name.

Find Fraud Ring (An Example)

Find out how to use Procedure through the public fraud graph.

Find out how to use Procedure in practice through the insurance fraud graph we checked earlier.
Fraud Ring is an example of a cycle structure that occurs between two or more criminals during a public fraud.
Traditional graph pattern searches have a large number of cases or complicatedly intertwined, making them difficult to recognize at a glance and limited in obtaining the desired results.
With the help of Stored Procedure, let's explore Path to avoid duplicating the ID of the Vertex that makes up the Fraud Ring.

Use the conspiracy fraud graph to learn how to use Procedure.

First, you need to look up the Graph Path of the Cycle structure passing through the specified vertex.
You can query any path that contains it by specifying the specified Vertex as a query in the Cypher language.
Duplicate Paths may exist because they are output without considering bidirectional edges.
The unique Vertex ID can be retrieved from the path inquired through Stored Procedure to exclude cases where the same path appears.

Create Graph

Paste the following Code in AGCloud's AGviewer to Create the Graph

CREATE(Male101:person{Name:'Male101', Gender:'Male', Age:'37', Residence:'Philadelphia'})
CREATE(Female101:person{Name:'Female101', Gender:'Female', Age:'39',Residence:'Houston'})
CREATE(Male102:person{Name:'Male102', Gender:'Male', Age:'45',Residence:'San Francisco'})
CREATE(Male103:person{Name:'Male103', Gender:'Male', Age:'41',Residence:'San Francisco'})
CREATE(Female102:person{Name:'Female102', Gender:'Female', Age:'35',Residence:'New York'})
CREATE(Male104:person{Name:'Male104', Gender:'Male', Age:'29',Residence:'New York'})
CREATE(Male105:person{Name:'Male105', Gender:'Male', Age:'51',Residence:'Chicago'})
CREATE(Female103:person{Name:'Female103', Gender:'Female', Age:'27',Residence:'New York'})
CREATE(Male106:person{Name:'Male106', Gender:'Male', Age:'29', Residence:'New York'})
CREATE(Male107:person{Name:'Male107', Gender:'Male', Age:'30', Residence:'New York'})
CREATE(Male108:person{Name:'Male108', Gender:'Male', Age:'31', Residence:'New York'})
CREATE(Male109:person{Name:'Male109', Gender:'Male', Age:'25', Residence:'New York'})
CREATE(Male110:person{Name:'Male110', Gender:'Male', Age:'25', Residence:'New York'})
CREATE(Male111:person{Name:'Male111', Gender:'Male', Age:'28', Residence:'New York'})
CREATE(Male112:person{Name:'Male112', Gender:'Male', Age:'33', Residence:'New York'})
CREATE(Male113:person{Name:'Male113', Gender:'Male', Age:'53', Residence:'New York'})
CREATE(Male114:person{Name:'Male114', Gender:'Male', Age:'22', Residence:'New York'})
CREATE(Male115:person{Name:'Male115', Gender:'Male', Age:'29', Residence:'Chicago'})
CREATE(Male116:person{Name:'Male116', Gender:'Male', Age:'46', Residence:'Chicago'})
CREATE(Male117:person{Name:'Male117', Gender:'Male', Age:'27', Residence:'Chicago'})
CREATE(Male118:person{Name:'Male118', Gender:'Male', Age:'27', Residence:'Chicago'})
CREATE(Male119:person{Name:'Male119', Gender:'Male', Age:'49', Residence:'San Francisco'})
CREATE(Male120:person{Name:'Male120', Gender:'Male', Age:'23', Residence:'San Francisco'})
CREATE(Male121:person{Name:'Male121', Gender:'Male', Age:'37', Residence:'San Francisco'})
CREATE(Male122:person{Name:'Male122', Gender:'Male', Age:'35', Residence:'San Francisco'})
CREATE(Male123:person{Name:'Male123', Gender:'Male', Age:'42', Residence:'San Francisco'})
CREATE(Male124:person{Name:'Male124', Gender:'Male', Age:'29', Residence:'San Francisco'})
CREATE(Male125:person{Name:'Male125', Gender:'Male', Age:'28', Residence:'San Francisco'})
CREATE(Male126:person{Name:'Male126', Gender:'Male', Age:'30', Residence:'San Francisco'})
CREATE(Male127:person{Name:'Male127', Gender:'Male', Age:'46', Residence:'San Francisco'})
CREATE(Male128:person{Name:'Male128', Gender:'Male', Age:'46', Residence:'San Francisco'})
CREATE(Male129:person{Name:'Male129', Gender:'Male', Age:'23', Residence:'San Francisco'})
CREATE(Male130:person{Name:'Male130', Gender:'Male', Age:'42', Residence:'San Francisco'})
CREATE(Female104:person{Name:'Female104', Gender:'Female', Age:'34', Residence:'New York'})
CREATE(Female105:person{Name:'Female105', Gender:'Female', Age:'38', Residence:'New York'})
CREATE(Female106:person{Name:'Female106', Gender:'Female', Age:'56', Residence:'New York'})
CREATE(Female107:person{Name:'Female107', Gender:'Female', Age:'28', Residence:'New York'})
CREATE(Female108:person{Name:'Female108', Gender:'Female', Age:'30', Residence:'New York'})
CREATE(Female109:person{Name:'Female109', Gender:'Female', Age:'41', Residence:'New York'})
CREATE(Female110:person{Name:'Female110', Gender:'Female', Age:'21', Residence:'New York'})
CREATE(Female111:person{Name:'Female111', Gender:'Female', Age:'56', Residence:'New York'})
CREATE(Female112:person{Name:'Female112', Gender:'Female', Age:'44', Residence:'New York'})
CREATE(Female113:person{Name:'Female113', Gender:'Female', Age:'42', Residence:'San Francisco'})
CREATE(Female114:person{Name:'Female114', Gender:'Female', Age:'21', Residence:'San Francisco'})
CREATE(Female115:person{Name:'Female115', Gender:'Female', Age:'28', Residence:'San Francisco'})
CREATE(Female116:person{Name:'Female116', Gender:'Female', Age:'58', Residence:'San Francisco'})
CREATE(Female117:person{Name:'Female117', Gender:'Female', Age:'42', Residence:'San Francisco'})
CREATE(Female118:person{Name:'Female118', Gender:'Female', Age:'49', Residence:'San Francisco'})
CREATE(Female119:person{Name:'Female119', Gender:'Female', Age:'51', Residence:'Chicago'})
CREATE(Female120:person{Name:'Female120', Gender:'Female', Age:'27', Residence:'Chicago'})


-- CREATE CARS
CREATE(N1111:car{Car_num:'1111',Manufacturer:'Hyundai-Kia', Name:'K5'})
CREATE(N1234:car{Car_num:'1234',Manufacturer:'Ford', Name:'Explorer'})
CREATE(N1512:car{Car_num:'1512',Manufacturer:'Hyundai-Kia', Name:'Sorento'})
CREATE(N1616:car{Car_num:'1616',Manufacturer:'Volkswagen', Name:'POLO'})
CREATE(N1717:car{Car_num:'1717',Manufacturer:'Chevrole', Name:'Cruze'})
CREATE(N1712:car{Car_num:'1712',Manufacturer:'BMW', Name:'BMW520'})
CREATE(N2706:car{Car_num:'2706',Name:'The BEETLE',Manufacturer:'Volkswagen'})
CREATE(N5793:car{Car_num:'5793',Name:'Scirocco',Manufacturer:'Volkswagen'})
CREATE(N4278:car{Car_num:'4278',Name:'JETTA'    ,Manufacturer:'Volkswagen'})
CREATE(N5241:car{Car_num:'5241',Name:'CELTOS',Manufacturer:'Hyundai-Kia'})
CREATE(N4176:car{Car_num:'4176',Name:'Kuga',Manufacturer:'Ford'})
CREATE(N6512:car{Car_num:'6512',Name:'GOLF',Manufacturer:'Volkswagen'})
CREATE(N5595:car{Car_num:'5595',Name:'A3',Manufacturer:'Audi'})
CREATE(N8523:car{Car_num:'8523',Name:'Sportage',Manufacturer:'Hyundai-Kia'})
CREATE(N4332:car{Car_num:'4332',Name:'Mustang',Manufacturer:'Ford'})
CREATE(N9908:car{Car_num:'9908',Name:'POLO',Manufacturer:'Volkswagen'})
CREATE(N5761:car{Car_num:'5761',Name:'K5',Manufacturer:'Hyundai-Kia'})
CREATE(N1679:car{Car_num:'1679',Name:'Cruze',Manufacturer:'Chevrole'})
CREATE(N9942:car{Car_num:'9942',Name:'A3',Manufacturer:'Audi'})
CREATE(N9150:car{Car_num:'9150',Name:'GOLF',Manufacturer:'Volkswagen'})
CREATE(N8644:car{Car_num:'8644',Name:'POLO',Manufacturer:'Volkswagen'})
CREATE(N6712:car{Car_num:'6712',Name:'K5',Manufacturer:'Hyundai-Kia'})
CREATE(N8334:car{Car_num:'8334',Name:'POLO' ,Manufacturer:'Volkswagen'})
CREATE(N9330:car{Car_num:'9330',Name:'K5',Manufacturer:'Hyundai-Kia'})
CREATE(N3454:car{Car_num:'3454',Name:'Morning',Manufacturer:'Hyundai-Kia'})
CREATE(N7236:car{Car_num:'7236',Name:'Morning',Manufacturer:'Hyundai-Kia'})
CREATE(N8076:car{Car_num:'8076',Name:'Ray',Manufacturer:'Hyundai-Kia'})
CREATE(N7445:car{Car_num:'7445',Name:'BMW520',Manufacturer:'BMW'})



-- CREATE ACCIDENTS

CREATE (ACC19111:accident {Name:'19111', accident_date:'19/05/2020', City:'New York'})
CREATE (ACC19222:accident {Name:'19222', accident_date:'23/05/2020', City:'Chicago'})
CREATE (ACC19333:accident {Name:'19333', accident_date:'27/05/2020', City:'Jacksonville'})
CREATE (ACC19292:accident {Name:'19292', accident_date:'11/05/2020',City:'New York'})
CREATE (ACC19419:accident {Name:'19419', accident_date:'13/05/2020',City:'Chicago'})
CREATE (ACC19314:accident {Name:'19314', accident_date:'08/05/2020',City:'Jacksonville'})
CREATE (ACC19400:accident {Name:'19400', accident_date:'10/05/2020',City:'Dallas'})
CREATE (ACC19830:accident {Name:'19830', accident_date:'16/05/2020',City:'Phoenix'})
CREATE (ACC19706:accident {Name:'19706', accident_date:'16/05/2020',City:'San Diego'})
CREATE (ACC19666:accident {Name:'19666', accident_date:'14/05/2020',City:'San Jose'})
CREATE (ACC19104:accident {Name:'19104', accident_date:'03/05/2020',City:'New York'})
CREATE (ACC19430:accident {Name:'19430', accident_date:'10/05/2020',City:'Dallas'})
CREATE (ACC19223:accident {Name:'19223', accident_date:'22/05/2020',City:'Jacksonville'})
CREATE (ACC19565:accident {Name:'19565', accident_date:'14/05/2020',City:'Chicago'})


-- CREATE CARS_ACCIDENTS EDGES
CREATE (N1111)-[:IS_INVOLVED]->(ACC19111)
MERGE (N1234)-[:IS_INVOLVED]->(ACC19111)
MERGE (N1512)-[:IS_INVOLVED]->(ACC19222)
MERGE (N1616)-[:IS_INVOLVED]->(ACC19222)
MERGE (N1717)-[:IS_INVOLVED]->(ACC19333)
MERGE (N1712)-[:IS_INVOLVED]->(ACC19333)
MERGE (N2706)-[:IS_INVOLVED]->(ACC19292)
MERGE (N5793)-[:IS_INVOLVED]->(ACC19292)
MERGE (N4278)-[:IS_INVOLVED]->(ACC19419)
MERGE (N5241)-[:IS_INVOLVED]->(ACC19419)
MERGE (N4176)-[:IS_INVOLVED]->(ACC19314)
MERGE (N6512)-[:IS_INVOLVED]->(ACC19314)
MERGE (N5595)-[:IS_INVOLVED]->(ACC19400)
MERGE (N8523)-[:IS_INVOLVED]->(ACC19400)
MERGE (N4332)-[:IS_INVOLVED]->(ACC19830)
MERGE (N9908)-[:IS_INVOLVED]->(ACC19830)
MERGE (N5761)-[:IS_INVOLVED]->(ACC19706)
MERGE (N1679)-[:IS_INVOLVED]->(ACC19706)
MERGE (N9942)-[:IS_INVOLVED]->(ACC19666)
MERGE (N9150)-[:IS_INVOLVED]->(ACC19666)
MERGE (N8644)-[:IS_INVOLVED]->(ACC19104)
MERGE (N6712)-[:IS_INVOLVED]->(ACC19104)
MERGE (N2706)-[:IS_INVOLVED]->(ACC19292)
MERGE (N5793)-[:IS_INVOLVED]->(ACC19292)
MERGE (N4278)-[:IS_INVOLVED]->(ACC19419)
MERGE (N5241)-[:IS_INVOLVED]->(ACC19419)
MERGE (N4176)-[:IS_INVOLVED]->(ACC19314)
MERGE (N6512)-[:IS_INVOLVED]->(ACC19314)
MERGE (N5595)-[:IS_INVOLVED]->(ACC19400)
MERGE (N8523)-[:IS_INVOLVED]->(ACC19400)
MERGE (N4332)-[:IS_INVOLVED]->(ACC19830)
MERGE (N8334)-[:IS_INVOLVED]->(ACC19430)
MERGE (N9330)-[:IS_INVOLVED]->(ACC19430)
MERGE (N3454)-[:IS_INVOLVED]->(ACC19223)
MERGE (N7236)-[:IS_INVOLVED]->(ACC19223)
MERGE (N8076)-[:IS_INVOLVED]->(ACC19565)
MERGE (N7445)-[:IS_INVOLVED]->(ACC19565)
MERGE (N9908)-[:IS_INVOLVED]->(ACC19830)
MERGE (N5761)-[:IS_INVOLVED]->(ACC19706)
MERGE (N1679)-[:IS_INVOLVED]->(ACC19706)
MERGE (N9942)-[:IS_INVOLVED]->(ACC19666)
MERGE (N9150)-[:IS_INVOLVED]->(ACC19666)
MERGE (N8644)-[:IS_INVOLVED]->(ACC19430)
MERGE (N6712)-[:IS_INVOLVED]->(ACC19430)
MERGE (N2706)-[:IS_INVOLVED]->(ACC19223)
MERGE (N5793)-[:IS_INVOLVED]->(ACC19223)
MERGE (N4278)-[:IS_INVOLVED]->(ACC19565)
MERGE (N5241)-[:IS_INVOLVED]->(ACC19565)



CREATE (Male101)-[:DRIVER]->(N1111)
CREATE (Male101)-[:PASSENGER]->(N1512)
CREATE (Male101)-[:PASSENGER]->(N1717)
CREATE (Female101)-[:DRIVER]->(N1234)
CREATE (Female101)-[:PASSENGER]->(N1616)
CREATE (Female101)-[:PASSENGER]->(N1712)
CREATE (Male102)-[:DRIVER]->(N1512)
CREATE (Male102)-[:PASSENGER]->(N1111)
CREATE (Male102)-[:PASSENGER]->(N1712)
CREATE (Male103)-[:DRIVER]->(N1616)
CREATE (Male103)-[:PASSENGER]->(N1717)
CREATE (Male103)-[:PASSENGER]->(N1234)
CREATE (Female102)-[:DRIVER]->(N1717)
CREATE (Female102)-[:PASSENGER]->(N1616)
CREATE (Female102)-[:PASSENGER]->(N1111)
CREATE (Male104)-[:DRIVER]->(N1712)
CREATE (Male104)-[:PASSENGER]->(N1234)
CREATE (Male104)-[:PASSENGER]->(N1512)
CREATE (Male105)-[:IS_DOCTOR]->(Male101)
CREATE (Male105)-[:IS_DOCTOR]->(Male102)
CREATE (Male105)-[:IS_DOCTOR]->(Female102)
CREATE (Female103)-[:IS_INSU_AGENT]->(Female101)
CREATE (Female103)-[:IS_INSU_AGENT]->(Male102)
CREATE (Female103)-[:IS_INSU_AGENT]->(Male103)
CREATE (Female103)-[:IS_INSU_AGENT]->(Female102)
CREATE (Male106)-[:DRIVER]->(N2706)
CREATE (Male107)-[:DRIVER]->(N5793)
CREATE (Male108)-[:DRIVER]->(N4278)
CREATE (Male109)-[:DRIVER]->(N5241)
CREATE (Male110)-[:DRIVER]->(N4176)
CREATE (Male111)-[:DRIVER]->(N6512)
CREATE (Male112)-[:DRIVER]->(N5595)
CREATE (Male113)-[:DRIVER]->(N8523)
CREATE (Male114)-[:DRIVER]->(N4332)
CREATE (Male115)-[:DRIVER]->(N9908)
CREATE (Male116)-[:DRIVER]->(N5761)
CREATE (Male117)-[:DRIVER]->(N1679)
CREATE (Male118)-[:DRIVER]->(N9942)
CREATE (Male119)-[:DRIVER]->(N9150)
CREATE (Male120)-[:DRIVER]->(N8644)
CREATE (Male121)-[:DRIVER]->(N6712)
CREATE (Male122)-[:PASSENGER]->(N2706)
CREATE (Male123)-[:PASSENGER]->(N5793)
CREATE (Male124)-[:PASSENGER]->(N4278)
CREATE (Male125)-[:PASSENGER]->(N5241)
CREATE (Male126)-[:PASSENGER]->(N4176)
CREATE (Male127)-[:PASSENGER]->(N6512)
CREATE (Male128)-[:PASSENGER]->(N5595)
CREATE (Male129)-[:PASSENGER]->(N8523)
CREATE (Male130)-[:PASSENGER]->(N4332)
CREATE (Female104)-[:DRIVER]->(N8334)
CREATE (Female105)-[:DRIVER]->(N9330)
CREATE (Female106)-[:DRIVER]->(N3454)
CREATE (Female107)-[:DRIVER]->(N7236)
CREATE (Female108)-[:DRIVER]->(N8076)
CREATE (Female109)-[:DRIVER]->(N7445)
CREATE (Female110)-[:PASSENGER]->(N9908)
CREATE (Female111)-[:PASSENGER]->(N5761)
CREATE (Female112)-[:PASSENGER]->(N1679)
CREATE (Female113)-[:PASSENGER]->(N9942)
CREATE (Female114)-[:PASSENGER]->(N9150)
CREATE (Female115)-[:PASSENGER]->(N8644)
CREATE (Female116)-[:PASSENGER]->(N6712)
CREATE (Female117)-[:PASSENGER]->(N2706)
CREATE (Female118)-[:PASSENGER]->(N5793)
CREATE (Female119)-[:PASSENGER]->(N4278)
CREATE (Female120)-[:PASSENGER]->(N5241);

To be Continued in Next Tutorial

DEV Community: Muhammad Farooq

How Apache AGE Works on Top of PostgreSQL

Introduction

What is a Graph Database?

Why Use Apache AGE?

How Does Apache AGE Work?

How to install Apache AGE Extension?

Conclusion

Popular Graph extensions to PostgreSQL

PostgreSQL

Apache AGE

pgRouting

Graphile

Conclusion

Integration of Apache AGE and Citus to Build a Scalable Graph Database on PostgreSQL

Graph Database

What is Apache AGE?

What is Citus?

Advantages of using Apache AGE and Citus Together?

Conclusion

How to Control Autovacuum Frequency in PostgreSQL

PostgreSQL

Autovacuum

Storage Parameters

Example

Apache AGE:

Conclusion

Features of PEM on top of PgAdmin

Introduction

PEM Console

PEM REST API

PEM CLI

Features Extended by PEM:

Apache AGE

Conclusion

Enterprise managers built on top of pgAdmin

What is pgAdmin?

What are enterprise managers?

Some of these features include:

How to get started with enterprise managers?

Apache AGE

Conclusion

When to use RDB or GDB?

Fast analysis or Log management

Depth of relationship

Consistency of data model

RGDB: a multi-model that can use both RDB & GDB

The purpose is the key

Visit Apache AGE:

Advantages of Relational DB, Graph DB, and RGDB

Introduction to Relational DB & Graph DB

Relational Database

Graph Database

Reference

Visit Bitnine and Apache AGE

Explainable AI and Graph Database

What is XAI - Explainable AI

Explainable AI & Machine Learning & Graph Analytics

Decision Tree - A Classic Example

Graph Interpretation

Advantages of XAI

Use of Graph in traditional ML

XAI and Graph Analytics

Graph processes large data quickly & efficiently

Reference

Also Visit Apache AGE

AgensSQL - Bitnine Global Inc

Introduction

Agens Enterprise Package:

Usability

AEM (Agens Enterprise Manager)

Scalability

AgensSQL Extension Server

Stability

AgensSQL DB Engine

Key Features

Data Security

High Availability

Monitoring

Data Sharding