DEV Community: moaz178

An In-depth Look at Arrays and Sorting Algorithms

moaz178 — Tue, 18 Jul 2023 17:04:08 +0000

Arrays are fundamental data structures in computer programming that allow us to store and manipulate collections of elements. One common operation performed on arrays is sorting, which arranges the elements in a specific order. In this blog, we will explore the concept of arrays, understand their properties, and dive into different sorting algorithms used to order array elements efficiently.

Bubble Sort:

Bubble sort is a simple and straightforward sorting algorithm.
It iterates through the array repeatedly, comparing adjacent elements and swapping them if they are in the wrong order.
The process continues until the entire array is sorted.
Bubble sort has a time complexity of O(n^2), making it inefficient for large arrays.
Selection Sort:

Selection sort divides the array into two portions: sorted and unsorted.
It repeatedly selects the smallest element from the unsorted portion and moves it to the sorted portion.
The algorithm continues until the entire array is sorted.
Selection sort also has a time complexity of O(n^2), making it inefficient for large arrays.
Insertion Sort:

Insertion sort builds the final sorted array one element at a time.
It takes each element from the unsorted portion and inserts it into its correct position in the sorted portion.
The algorithm iterates through the array, shifting elements to make room for the inserted element.
Insertion sort has an average time complexity of O(n^2), but it performs well for small arrays or partially sorted arrays.
Merge Sort:

Merge sort is a divide-and-conquer algorithm that divides the array into smaller subarrays until each subarray contains only one element.
It then merges these subarrays to form a sorted array.
Merge sort has a time complexity of O(n log n), making it more efficient than the previous algorithms for large arrays.
However, it requires additional memory for merging the subarrays.
Quick Sort:

Quick sort is another divide-and-conquer algorithm that selects a pivot element and partitions the array into two parts.
Elements smaller than the pivot are placed to its left, and elements greater than the pivot are placed to its right.
The algorithm then recursively sorts the two subarrays.
Quick sort has an average time complexity of O(n log n), but its worst-case time complexity is O(n^2) if the pivot selection is not optimal.
Quick sort is widely used due to its efficiency and can be improved using various optimizations.

These different algorithms play a pivotal role in data structuring, allowing arrays to be sorted based on desired requirements.

Test Automation in Software Development

moaz178 — Sun, 09 Jul 2023 13:07:22 +0000

In the world of software development, ensuring the quality of a product is paramount. One way to achieve this is through test automation, a process that involves using specialized tools and scripts to automate the execution of tests. Test automation offers numerous benefits, such as increased efficiency, faster feedback loops, and improved test coverage. In this blog post, we will explore the concept of test automation in software development and highlight its advantages, challenges, and best practices.

The Importance of Test Automation:
Testing is an integral part of software development, as it helps identify bugs, errors, and vulnerabilities. However, manual testing can be time-consuming, repetitive, and prone to human error. Test automation addresses these limitations by automating the execution of test cases, allowing developers and testers to focus on more critical and complex tasks.

Benefits of Test Automation:
1) Increased Efficiency: Automated tests can be executed quickly and repeatedly, reducing the time and effort required for regression testing. This enables teams to deliver software faster and more frequently.
2) Faster Feedback Loops: With automated tests, developers receive immediate feedback on the quality and functionality of their code, enabling them to address issues promptly and iterate rapidly.
3) Improved Test Coverage: Automated tests can cover a broad range of scenarios and edge cases, ensuring comprehensive testing that may be challenging to achieve manually.
4) Cost Savings: Although there are upfront costs associated with implementing test automation, the long-term benefits outweigh them. Automation reduces the need for extensive manual testing, leading to cost savings in the long run.

Challenges and Considerations:
1) Test Maintenance: As software evolves, tests need to be updated and maintained to align with changes in functionality. Regular maintenance efforts are crucial to ensure the accuracy and effectiveness of automated tests.
2) Initial Investment: Implementing test automation requires an investment of time, resources, and expertise. Organizations must carefully plan and allocate resources to ensure a successful automation initiative.
3) Test Selection: Not all tests are suitable for automation. It is essential to identify tests that provide the most value when automated, such as repetitive or critical test scenarios.
4) Collaboration and Skill Set: Collaboration between developers and testers is vital for successful test automation. Additionally, teams need to possess the necessary technical skills to create and maintain automated test scripts effectively.

Best Practices for Test Automation:
1) Test Planning: Define clear objectives, scope, and goals for automation to ensure a focused and effective approach.
2) Test Design: Create reusable and modular test scripts to maximize efficiency and maintainability.
3) Test Data Management: Develop strategies for managing test data to ensure a consistent and reliable testing environment.
4) Continuous Integration: Integrate automated tests into the continuous integration and delivery pipeline to enable frequent and automated testing.
5) Regular Review and Maintenance: Regularly review and update automated tests to keep pace with changes in the software and maintain their relevance and effectiveness.

The Power of Unit Testing: Building Robust and Reliable Software

moaz178 — Mon, 26 Jun 2023 10:33:07 +0000

In the world of software development, ensuring the quality and reliability of our code is of utmost importance. One powerful technique that helps us achieve this goal is unit testing. Unit testing involves writing small, focused tests to verify the correctness of individual units of code, such as functions or methods. In this blog post, we'll explore the concept of unit testing, its benefits, and some best practices to follow.

What is Unit Testing?
Unit testing is a software development practice that involves isolating and testing individual units of code in isolation to ensure they function as expected. A unit refers to the smallest testable part of an application, often a single function or method. These tests are typically automated, and they help developers identify and fix bugs early in the development process.

Benefits of Unit Testing:
Unit testing offers numerous benefits for software development projects, including:

Early bug detection: By testing individual units of code, developers can catch bugs early in the development process, making them easier and cheaper to fix.
Code maintainability: Unit tests act as documentation for the expected behavior of the code. They make it easier for developers to understand and modify the codebase, ensuring that changes do not introduce unexpected issues.
Better code design: Unit testing promotes the use of modular, loosely coupled code, making it easier to test and maintain.
Regression testing: Unit tests act as a safety net when refactoring or adding new features, allowing developers to quickly verify that existing functionality has not been broken.
Faster development: Although writing unit tests requires some upfront effort, it often leads to faster development in the long run by reducing time spent on debugging and manual testing.

Best Practices for Unit Testing:
To maximize the effectiveness of unit tests, consider the following best practices:
Test individual units in isolation: Each unit test should focus on testing a specific unit of code without relying on the behavior of other units. Use mocks or stubs to isolate dependencies.
Keep tests small and focused: Each unit test should verify a single behavior or scenario, making it easier to identify the cause of failures and maintain the tests in the long run.
Use descriptive test names: Clear and descriptive test names make it easier to understand the purpose of each test and identify the cause of failures.
Test edge cases and boundary conditions: Ensure that your unit tests cover a wide range of inputs, including edge cases and boundary conditions, to catch potential issues.
Automate your tests: Automating your unit tests enables you to run them frequently and easily integrate them into your continuous integration (CI) and continuous delivery (CD) pipelines.
Test for both expected and unexpected behaviors: Besides verifying expected behaviors, also include tests to handle unexpected or erroneous inputs, ensuring that your code fails gracefully.

Popular Unit Testing Frameworks:
Several unit testing frameworks are widely used in different programming languages, including:
JUnit: A popular framework for Java unit testing.
pytest: A flexible and powerful testing framework for Python.
NUnit: A unit testing framework for .NET languages such as C#.
Jasmine: A behavior-driven development (BDD) framework for JavaScript.
PHPUnit: A unit testing framework for PHP.

Conclusion:
Unit testing is an essential practice for building robust and reliable software. By writing automated tests for individual units of code, developers can catch bugs early, improve code maintainability, and ensure faster development. Embracing unit testing, along with adopting best practices and leveraging the right testing frameworks, empowers developers to create high-quality software that meets user expectations and stands the test of time.

A Comparative Analysis: PostgreSQL vs. MongoDB

moaz178 — Fri, 16 Jun 2023 17:57:25 +0000

When it comes to choosing a database management system (DBMS) for your application, you have a plethora of options available. Two popular choices among developers are PostgreSQL and MongoDB. While both are well-known and widely used, they differ significantly in their approach to data storage, querying capabilities, and data modeling. In this blog post, we will explore the key differences between PostgreSQL and MongoDB to help you make an informed decision for your specific use case.

Data Model:
PostgreSQL: PostgreSQL is a relational database management system (RDBMS) based on the SQL (Structured Query Language) paradigm. It follows a table-based data model, where data is organized into tables with predefined schemas and relationships between tables through foreign key constraints.
MongoDB: MongoDB, on the other hand, is a document-oriented NoSQL database. It uses a flexible, schema-less document model, where data is stored in collections made up of JSON-like documents. Each document can have a different structure, allowing for dynamic and unstructured data storage.

Scalability:
PostgreSQL: PostgreSQL is highly scalable and can handle large amounts of data. It supports horizontal scalability through techniques like sharding and replication. However, scaling PostgreSQL requires careful planning and setup.
MongoDB: MongoDB is designed to be horizontally scalable out of the box. It uses a technique called sharding, which allows distributing data across multiple servers or shards. This makes MongoDB a good choice for applications that require high scalability and performance.

Querying and Indexing:
PostgreSQL: As an RDBMS, PostgreSQL provides powerful querying capabilities using SQL. It supports complex joins, subqueries, and advanced filtering. It also offers a wide range of indexing options, including B-tree, hash, and generalized inverted indexes (GIN and GiST), allowing for efficient data retrieval.
MongoDB: MongoDB has a flexible query language that allows for querying documents using a rich set of operators. It supports ad-hoc queries, but the lack of SQL-like joins can make querying across multiple collections more challenging. MongoDB uses indexes (including compound indexes) to optimize query performance.

Transactions and ACID Compliance:
PostgreSQL: PostgreSQL is renowned for its support of ACID (Atomicity, Consistency, Isolation, Durability) properties. It provides robust transaction support, allowing developers to maintain data integrity and consistency within the database.
MongoDB: While MongoDB introduced multi-document transactions in recent versions, it traditionally favored a more flexible approach called "document-level atomicity." This means that operations within a single document are atomic, but across multiple documents, atomicity is not guaranteed. MongoDB's focus has been on scalability and performance, sacrificing some ACID properties.

PostgreSQL and MongoDB cater to different data management needs, and choosing the right one depends on your specific use case. PostgreSQL shines when structured data and complex relationships are paramount, while MongoDB excels at handling unstructured and rapidly changing data, offering high scalability and performance

AgensSQL and its Benefits

moaz178 — Sat, 10 Jun 2023 13:23:53 +0000

AgensSQL is an advanced and extensible relational database management system (RDBMS) that is based on the PostgreSQL open-source project. It is designed to provide high performance, scalability, and reliability for complex data management tasks

Here are some key features and components of AgensSQL:
Graph Database Functionality: AgensSQL incorporates graph database capabilities, allowing users to store, manage, and query graph data. It introduces graph-specific data types, such as vertexes and edges, and provides graph traversal and pattern matching queries.

Cypher Query Language: AgensSQL supports the Cypher query language, which is a declarative language specifically designed for querying graph data. Cypher allows users to express graph patterns and relationships in a concise and intuitive manner.

Graph Data Model: AgensSQL introduces a graph data model, where data is represented as interconnected nodes (vertexes) and relationships (edges). This model is ideal for representing complex and highly connected data structures, such as social networks, recommendation systems, and knowledge graphs.

SQL Compatibility: AgensSQL maintains compatibility with the SQL language, allowing users to leverage their existing SQL skills and tools. It supports standard SQL queries for relational data, and the Cypher language for graph data, providing a unified query interface.

Graph Analytics: AgensSQL includes built-in graph analytics capabilities, allowing users to perform complex graph algorithms and computations. It supports a range of graph algorithms, such as PageRank, community detection, shortest path, and centrality measures.

Extensibility: AgensSQL provides an extensible architecture that allows developers to create custom functions, data types, and operators. This extensibility enables users to extend the system's capabilities and adapt it to their specific requirements.

High Performance: AgensSQL is designed to deliver high performance for both relational and graph data processing. It takes advantage of PostgreSQL's performance optimizations and introduces additional optimizations for graph queries, such as index-based graph traversal and parallel processing.

Scalability and Replication: AgensSQL offers scalability and replication features to handle large datasets and high workloads. It supports horizontal scaling through sharding and provides replication mechanisms for high availability and fault tolerance.

Integration: AgensSQL integrates with other tools and frameworks commonly used in the data ecosystem. It supports data import/export in various formats, including CSV, JSON, and RDF. It also provides connectors for popular programming languages and frameworks like Python, Java, and JDBC.

Open-Source and Community Support: AgensSQL is an open-source project, built on top of the PostgreSQL community. It benefits from a vibrant and active community that contributes to its development, provides support, and shares knowledge and best practices.

Understanding Relational Database Management Systems (RDBMS)

moaz178 — Thu, 01 Jun 2023 17:48:50 +0000

In the world of data management, Relational Database Management Systems (RDBMS) have been the backbone of countless applications and organizations. RDBMS provide a structured and efficient approach to storing and retrieving data.
**
What is an RDBMS?**
A Relational Database Management System (RDBMS) is a software system designed to manage relational databases. It is based on the relational model, which organizes data into tables with rows and columns. RDBMS provide a set of operations and tools to create, modify, and query these databases.

Key Features of RDBMS:

**Data Integrity: **RDBMS enforce data integrity rules, such as entity integrity (primary key uniqueness) and referential integrity (relationship between tables).

ACID Properties: RDBMS ensure transactional integrity through ACID properties (Atomicity, Consistency, Isolation, Durability), allowing for reliable and robust data operations.
SQL Support: RDBMS use SQL as the standard language for interacting with databases, making it easy to query, manipulate, and retrieve data.

Data Relationships: RDBMS facilitate establishing relationships between tables using primary and foreign keys, enabling efficient data retrieval through joins.
Indexing: RDBMS support indexing mechanisms to improve query performance by allowing faster data access.

Scalability: RDBMS can scale vertically (adding more resources to a single server) or horizontally (distributing data across multiple servers) to handle growing data volumes and user loads.

Popular RDBMS:

MySQL: An open-source RDBMS widely used for web applications and small to medium-sized databases.

Oracle Database: A commercial RDBMS known for its scalability, reliability, and extensive feature set.

Microsoft SQL Server: A relational database system developed by Microsoft, offering excellent integration with the Microsoft technology stack.
**
PostgreSQL:** An open-source RDBMS with advanced features and strong adherence to standards.

IBM Db2: A robust RDBMS designed for enterprise-level applications and known for its performance and scalability.

Conclusion:
Relational Database Management Systems (RDBMS) have played a vital role in managing structured data for decades. With their emphasis on data integrity, flexibility, and scalability, RDBMS provide a reliable and efficient solution for storing and retrieving data. Understanding the principles and features of RDBMS is crucial for developers, data analysts, and anyone involved in working with data.

Graph Database Models

moaz178 — Fri, 26 May 2023 06:36:47 +0000

Introduction:
Graph databases have gained significant popularity in recent years due to their ability to efficiently manage highly connected data and relationships. In this blog post, we will delve into the world of graph database models, exploring their components, characteristics, and how they differ from traditional relational databases. By understanding the various graph database models available, you can make informed decisions when choosing the right model for your data and application requirements.

Property Graph Model:
The property graph model is the most common and widely adopted graph database model. It represents data as nodes, relationships, and properties, making it intuitive and easy to understand. We will explore the key components of the property graph model, including nodes, relationships, labels, and properties, along with their role in representing complex real-world relationships.

RDF Graph Model:
The RDF (Resource Description Framework) graph model, on the other hand, focuses on representing data as subject-predicate-object triples. It provides a standardized way to express relationships between resources on the web. We will discuss the basics of the RDF model, exploring its components, such as resources, properties, and URIs, and how it enables interoperability and data integration across different systems.

Comparison and Considerations:
Next, we will compare the property graph and RDF graph models, highlighting their strengths, weaknesses, and ideal use cases. Understanding the trade-offs between the two models will help you choose the most suitable one for your specific requirements. We will discuss factors such as data complexity, query flexibility, scalability, and ecosystem support.
**
Hybrid and Extended Models:**
In addition to the two primary graph database models, we will touch upon hybrid models that combine elements of both property graphs and RDF graphs. These models offer flexibility and versatility, allowing users to leverage the strengths of multiple graph representations. We will also explore any emerging graph database models or extensions that are gaining traction in the industry.

Choosing the Right Model:
Finally, we will provide guidelines and best practices for selecting the right graph database model based on your project's requirements. Factors such as data structure, query patterns, performance considerations, and existing system integrations will be discussed to help you make an informed decision.

Conclusion:
Graph database models provide powerful and flexible ways to represent and manage highly connected data. By understanding the nuances and characteristics of different graph database models, you can effectively leverage their capabilities to build robust and efficient applications. Whether it's the intuitive property graph model or the interoperable RDF graph model, selecting the right model is crucial for the success of your graph database implementation.

Database Normalization and De-Normalization.

moaz178 — Sun, 21 May 2023 18:15:14 +0000

Normalization is a process that helps organize relational databases into logical and efficient structures by eliminating data redundancy and ensuring data integrity. It involves decomposing large tables into smaller ones based on specific rules and dependencies. The most common normalization forms include First Normal Form (1NF), Second Normal Form (2NF), and Third Normal Form (3NF).

First Normal Form (1NF):
1NF requires that each attribute within a table contains only atomic (indivisible) values. It eliminates repeating groups and ensures that each row has a unique identifier (primary key).

Second Normal Form (2NF):
2NF builds upon 1NF and addresses partial dependencies. It requires that all non-key attributes depend on the entire primary key, rather than just a portion of it. This form ensures each attribute is functionally dependent on the primary key.

Third Normal Form (3NF):
3NF further refines the normalization process by addressing transitive dependencies. It mandates that no non-key attribute depends on other non-key attributes within the same table. In other words, it removes indirect relationships between non-key attributes.

** Benefits of Normalization:**

Data integrity:
Normalization helps prevent anomalies such as insertion, deletion, and update anomalies, ensuring data consistency.

Reduced redundancy: **
By eliminating redundant data, normalization reduces storage requirements and avoids inconsistencies.
**Improved query performance:
Normalized tables are typically optimized for efficient data retrieval, leading to faster query execution.

Denormalization:
Denormalization is the process of selectively reintroducing redundancy into a database to improve query performance or simplify data retrieval. While normalization aims to minimize redundancy, denormalization acknowledges that in certain scenarios, duplicating data can be beneficial.

Types of Denormalization:

Flattening:
Combining related tables into a single table to eliminate the need for joins.
Redundant Columns: Adding duplicate data to a table to avoid joins and improve query performance.
Summary Tables:
Creating aggregated tables that contain pre-computed summaries of data to speed up analytical queries.
Materialized Views:
Storing the results of complex queries as physical tables to enhance query performance.

Benefits of Denormalization:

Improved query performance: **
By reducing the number of joins or eliminating them altogether, denormalization can significantly enhance query execution speed.
**Simplified data model:
Denormalized structures can simplify application development and reduce complexity.
Reduced resource consumption:
Denormalization can decrease the demand for computational resources, such as CPU and memory, during query execution.

Postgres and Gaming

moaz178 — Fri, 05 May 2023 18:53:30 +0000

PostgreSQL is a powerful and reliable open-source relational database management system that can be used in gaming

Following are the crucial steps for its implentation:

Setting up a PostgreSQL database
To set up a PostgreSQL database, you need to download and install PostgreSQL on your server or local machine. You can download PostgreSQL from the official website or use a package manager if your operating system supports it.

Once PostgreSQL is installed, you need to create a new database by running the createdb command in your terminal. For example, to create a new database called "gamedata", you can run the following command in your terminal:

createdb gamedata

Connecting to the PostgreSQL database
To connect to the PostgreSQL database using JavaScript, you will need to use a PostgreSQL driver. You can choose a driver that is compatible with your JavaScript framework or library. For example, if you are using Node.js, you can use the pg driver.

To connect to the database using the pg driver, you can use the following code:

_const { Pool } = require('pg');

const pool = new Pool({
user: 'username',
host: 'localhost',
database: 'gamedata',
password: 'password',
port: 5432,
});_
This code creates a new connection pool to the "gamedata" database on the local machine using the specified username and password.

Creating database tables
Once you are connected to the PostgreSQL database, you need to create database tables to store your game data. You can create database tables using SQL commands. For example, you can use the following code to create a table to store player data:

pool.query(CREATE TABLE players ( id SERIAL PRIMARY KEY, name VARCHAR(50) NOT NULL, level INTEGER NOT NULL, score INTEGER NOT NULL ));
This creates a table called "players" with columns for the player's ID, name, level, and score.

Inserting data into the database
Once your database tables are created, you can insert data into the database using SQL commands. For example, you can use the following code to insert a new player record into the "players" table with the name "Player 1", level 1, and score 100:

pool.query(INSERT INTO players (name, level, score) VALUES ('Player 1', 1, 100));

Retrieving data from the database
You can retrieve data from the database using SQL queries.

_const result = await pool.query('SELECT * FROM players');
console.log(result.rows);
_

Updating and deleting data in the database
You can update and delete data in the database using SQL commands

pool.query(UPDATE players SET score = 200 WHERE id = 1);

For Deletion:

pool.query(DELETE FROM players WHERE id = 1);

Foreign Data Wrappers in Postgres

moaz178 — Wed, 03 May 2023 18:04:25 +0000

**Foreign Data Wrappers **in PostgreSQL allow you to access data from remote data sources, such as other PostgreSQL servers or other relational or non-relational databases, as if they were local tables. This allows you to integrate data from different sources and perform complex queries across multiple data sources.

To use an FDW in PostgreSQL, first we need to create a foreign server object that defines the connection to the remote data source.

This includes specifying the type of database system or data source being accessed, the hostname and port number of the remote server, and any necessary authentication credentials.

Then, can create a foreign table in your local PostgreSQL database that maps to a table or query in the remote data source. This involves defining the columns and data types of the foreign table, and specifying the mapping between the columns of the foreign table and the columns of the remote table or query.

When you query the foreign table in PostgreSQL, PostgreSQL will automatically translate the query into the appropriate syntax for the remote data source and send the query to the remote server for execution.

The remote server will return the results of the query to PostgreSQL, which will then return the results to you as if you had queried a local table.

FDWs can be very useful for integrating data from different sources, particularly when the data is spread across multiple databases or data sources.

However, it's important to keep in mind that performance may be impacted by the network latency and bandwidth between the PostgreSQL server and the remote data source.

The delay between packets can happen and this can cause a slower query response.

Query Processing Subsystems in Postgres

moaz178 — Sun, 30 Apr 2023 10:49:35 +0000

In postgres, backend processes perform some operations to carry out a query provided by the client. This includes :

Parser
Analyzer
Rewriter
Planner
Executor

Parser:
This portion prepares the query to be processed by other operations that are subsequent in fashion. It creates a parse tree that is possible to be read by other operations.

Analyzer:
The semantic analysis of the query is performed by the analyzer and this generates a query tree from the parse tree. Attached below is the image of the query tree generated.

Rewriter:
The rewriter is the system that checks the rules stored and transforms the query tree according to the rules

Planner:
The planner receives the query tree from the rewriter and generates a plan tree. It is based on cost-based optimization.
Cost is just a number with no units to check the complexity of a process. It is a metric to analyse subsequent processes. In Postgres, it comprises of:

Startup Cost required to start a query. It is allocated before accessing the first tuple

Run Cost It is the cost to process all the tuples

Total Cost It is the sum of both startup cost and run cost.

Plan tree comprises of plan nodes that stores the information necessary for the subsequent operation to carry the actual implementation of the query.

Executor:

Executor takes up the plan nodes and carryout functions stored on each node. This is the step where the query is actually processed and functions are performed. It first carries out the sequential scan and then sorts the results

These are the brief descriptions about subsystems of postgres query. For a detailed explanation, you can visit this article: https://www.interdb.jp/pg/pgsql03.html

Memory Architecture of Postgres

moaz178 — Sat, 29 Apr 2023 11:32:45 +0000

Postgres is a relational database that runs with multiple processes on a single host.

Certain processes occurs inn postgres which are the following:

Postgres Server Process

This is the parent process. In the previous versions it was called postmater.
pg_ctl is the command that executes the postgres server. It provides a shared area in the memory, runs some backend processes and waits for the queries from client side. The server process listens to one network port that is set to default as 5432. Multiple postgres servers can be run on a single machine as well.

BackEnd process

A process which is called postgres is started by the postgres server, the parent process, and it waits for the queries. A specific database must be provided explicitly because it runs on a single database.

Background Processes

Certain background processes do happen along with backend processes that includes background wirter, WAL writer, statitics collector etc. These are not client-side processes.

Memory Architecture

Two categories are assigned in the memory architecture of postgres. These are

Shared Memory This is used by all of the processes of postgres. It is allocated by Postgres Server whenever it starts up.

Local Memory This is allocated by each backend process for its utility. For query processing each backend process allocates local memory.

Reference: "https://www.interdb.jp/pg/pgsql02.html"