DEV Community: Abirami Prabhakar

Digit Manipulation

Abirami Prabhakar — Wed, 08 Apr 2026 05:42:51 +0000

//Sum of Digits

int value = 12345;
         int res = 0;
         while ( value > 0){
            res = res + ( value % 10);
            value = value / 10;
        }
        System.out.println(res);

//Reverse a digit

int value = 12345;
        int res = 0;
        int rem = 0;
        while ( value > 0){
             res = (value %10);
             rem = rem *10 + res;
             value = value/10;    
         }
        System.out.println(rem);

//Multiplying all didgits

 int value = 2546987;
        int res = 1;
        while (value > 0){
            res = res *(value %10);
            value = value/10;
        }
        System.out.println("The Multiplication of Digits is"+ res);

// Max of all didgits

int value = 67854095;
       int max = value % 10;
       while( value > 0){
        int lastdigit = value %10;
        if ( max < lastdigit){
            max = lastdigit;
        }
        value = value /10;
       }
       System.out.println("The largest digit " + max);

Armstrong Number - finding if the number is a armstrong number by using manual multiplication for finding the power

int num = 1634;
int aNum = 0;
int bcup = num;

while (num > 0) {
    int ld = num % 10;
    aNum += (ld * ld * ld * ld);
    num = num / 10;
}

if (bcup == aNum) {
    System.out.println("Is an Armstrong Number");
} else {
    System.out.println("Is NOT an Armstrong Number");
}

to find power of a number

int number = 10;
        int power = 4;
        int res = 1;
        for ( int i = 1 ; i <= power ; i++){
            res *= num
        }
        System.out.println("Power of give number is " + res);

Armstrong Number using a loop to find the power of number


int num = 1634;
            int aNum = 0;
            int bcup = num;
            int count = 0;
            while ( num > 0){    
                count++;
                num /= 10;
            }
            num = bcup;
            while ( num > 0){
                int ld = num %10;
                int pow = 1;
                for ( int i = 0; i < count ; i++){
                    pow = pow * ld;
                }
                aNum = aNum + pow;
                num /= 10;
            }
            if ( aNum == bcup){
                System.out.println("Is a Armstrong Number");
            } else {
                System.out.println("Is NOT a Armstrong Number");
            }

Setup a DNS hosted zone in Route53 in AWS.

Abirami Prabhakar — Sun, 29 Mar 2026 16:56:27 +0000

When I first tried setting up DNS in Amazon Web Services Route 53, I thought it would be straightforward—just create a hosted zone, add a record, and my website would magically work. I created a hosted zone with a random name, added an A record pointing to my EC2 public IP, and felt pretty confident.But then I reliazed it doesnt work as simple as I thought it will work like .

No matter what I tried, the domain wouldn’t open in the browser. That’s when I realized I had completely missed something basic—I didn’t even own a domain name. I had been treating Route 53 like it could create a website address for me, when in reality, it only manages DNS for domains that already exist.

That moment was frustrating, but also a turning point. I finally understood how DNS actually works: you need a registered domain first, and then you connect it to Route 53 using nameservers. Without that, there’s nothing for DNS to resolve.

In the end, I learned two important things. First, Route 53 is not a domain provider—it’s a DNS service. And second, if you don’t have a domain, you can still test your app using the EC2 public IP or DNS, which works perfectly for development.

It was a small mistake, but it made the whole concept much clearer. Sometimes, not having something—in this case, a domain—teaches you more than having everything set up correctly from the start.

Creating a hosted Zone in Route 53

Retriving the public IP of EC2 inatance to create a record

Creating Records

Users, Roles, Groups

Abirami Prabhakar — Sun, 29 Mar 2026 16:30:10 +0000

Think of a user as an individual person who logs into the database and does work. A role is like a set of permissions — what actions are allowed, like reading or updating data. Instead of giving permissions to each user one by one, we create groups (roles) and assign permissions to them, then simply add users to those groups. This way, managing access becomes much easier, because changing the role automatically updates permissions for everyone in it.lets look into some examples to understand better

Task 1: Create a login role report_user that can only read from the film table.

CREATE ROLE report_user WITH LOGIN PASSWORD 'pass123';
GRANT SELECT ON film TO report_user;

GRANT is used to grant access to use commands to roles

Task 2: Now try to access customer table. When report_user tries to query customer and gets permission denied. Fix it.

SELECT * FROM customer;
*Error prompted*
GRANT SELECT ON customer TO report_user;

as user was initially given access only yto film table, he was unable to access the customer table

Task 3: Allow report_user to see only customer_id, first_name, last_name of the customer table.

REVOKE SELECT ON customer FROM report_user;
GRANT SELECT (customer_id, first_name, last_name) ON customer TO report_user;

REVOKE is used to disable a user from doing certain commands in a table

Task 4: Create support_user who can, SELECT from customer, UPDATE only email column, Cannot DELETE

CREATE ROLE support_user WITH LOGIN PASSWORD 'pass123';
GRANT SELECT ON customer TO support_user;
GRANT UPDATE (email) ON customer TO support_user;
REVOKE DELETE ON customer FROM support_user;

Task 5: Remove SELECT access on film from report_user.

REVOKE SELECT ON film TO report_user;

Task 6: Create readonly_group that has SELECT on all tables.

CREATE ROLE readonly_group;
GRANT SELECT ON ALL TABLES IN SCHEMA public to readonly_group;

Task 7: Create analyst1 and analyst2 and add them to readonly_group.

CREATE ROLE analyst1 WITH LOGIN PASSWORD 'pass123';
CREATE ROLE analyst2 WITH LOGIN PASSWORD 'pass123';
GRANT readonly_group TO analyst1;
GRANT readonly_group TO analyst2;

Idempotency Situation

Abirami Prabhakar — Sun, 29 Mar 2026 16:08:04 +0000

Idempotency Situation is a when Even if the same request comes multiple times,it should behave like it happened only once this often happens in payment transactions due to network issues can be cause loss to customer if it is not handled properly.

This can be solves by keeping track of transactions and every bank transaction has a transaction ID and even if retry is given the trasaction takes place only once

The trasaction table keep a record all the amount that is transferred from a user to another user

CREATE TABLE transactions (
    id SERIAL PRIMARY KEY,
    sender TEXT,
    receiver TEXT,
    amount INT,
    idempotency_key TEXT UNIQUE
);

how it works

BEGIN;

INSERT INTO transactions (sender, receiver, amount, idempotency_key)
VALUES ('Alice', 'Bob', 200, 'txn_101');

UPDATE accounts SET balance = balance - 200 WHERE name = 'Alice';
UPDATE accounts SET balance = balance + 200 WHERE name = 'Bob';

COMMIT;

The data is entered before every transaction and then the query is updated

now, when the same transaction with the same idempotency_key is there for another query , an error is prompted because duplicate key values violates the unique constraint of the attribute

INSERT INTO transactions (sender, receiver, amount, idempotency_key)
VALUES ('Alice', 'Bob', 200, 'txn_101');

Consistency

Abirami Prabhakar — Sun, 29 Mar 2026 15:36:10 +0000

The consistency property in ACID, is to ensure that the transactions in queries are always in sense and all the constraints are satistfied before executing them and this in terms of wallet system can be a problem if a user tries to debit more than what is in their balance or update data in negative number and those can be stopped by being consistent

Examples of such situations and how an error is prompted to maintain consistency of the data

the balance is updated to negative value

UPDATE accounts 
SET balance = -100 
WHERE name = 'Alice';

an error is prompted

trying to debit more than the users balance

UPDATE accounts 
SET balance = balance - 2000 
WHERE name = 'Bob';

an error is prompted as cuz Bob only has balance of 500 in his account

Changes can be COMMIT only when the data is completely logically correct

Durablity

Abirami Prabhakar — Sun, 29 Mar 2026 15:26:45 +0000

Durability means once a transaction is successfully committed, its changes are permanently saved in the database. Yes, even when the system crashes, power failure or any other and this relaiblity in transaction is possible in databases like postgresql by WAL( Write Ahead Logs) where Before making actual changes, they first record the transaction in a log file. This way even if the system crashes before executing, the queries can be retrieved to execute them

In case of Wallet systems
Once money is transferred and confirmed, it will always be reflected and there is No risk of losing completed transactions and records for the user

BEGIN;

UPDATE accounts 
SET balance = balance - 100 
WHERE name = 'Alice';

COMMIT;

Atomicity

Abirami Prabhakar — Sun, 29 Mar 2026 15:20:05 +0000

Atomicity means a transaction is treated as one complete action, not separate steps. All the operations inside it must succeed together, or else none of them are applied. If something goes wrong in between, the system cancels everything and returns to the original state so no partial changes remain.

Atomicity is what makes a wallet system reliable for me. I see every transfer as one complete action, not separate steps. Either the full transaction happens or nothing happens at all. If something fails in between, everything is cancelled, so no money is lost and no partial updates occurs.

BEGIN;
initiatiing a transaction by detucting money from Alice
UPDATE accounts 
SET balance = balance - 200 
WHERE name = 'Alice';

making a error intentionlly 
UPDATE accounts 
SET balance = balance + 200 
WHERE name = 'Charlie';  (user Charlie does not exist)

COMMIT;

The Transaction does not take place and commit does not happen and rolledback

ROLLBACK;

Thus, Alice’s balance remains unchanged and No partial deduction happens, This is Atomicity

Alter Tables

Abirami Prabhakar — Sat, 28 Mar 2026 14:57:23 +0000

1. You have a table customers with a column email that currently allows NULL values. Modify the table so that future entries must always have an email.

ALTER TABLE customer
ALTER COLUMN email SET NOT NULL;

2. In the users table, ensure that the username column is unique across all records using an ALTER statement.

ALTER TABLE users
ADD CONSTRAINT unique_username UNIQUE (username);

the reason we cant deal with this like previous question is because , unique is a table level property can not be alter as a column property so we add it as a constraint

3. In the products table, enforce that price must always be greater than 0 using an ALTER command.

ALTER TABLE products
ADD CONSTRAINT price_check CHECK (price > 0);

checking values can be can be updated only as a constraint

4. Modify the orders table so that the status column defaults to 'pending' if no value is provided during insertion.

ALTER TABLE orders
ALTER COLUMN status SET DEFAULT 'pending';\

5. Alter the employees table by adding a new column salary such that
It cannot be NULL,It must always be greater than 10,000

ALTER TABLE employees
ADD COLUMN salary DECIMAL NOT NULL CHECK (salary > 10000);

6. Modify the foreign key constraint between employees and departments so that when a department is deleted, all related employees are automatically removed.

ALTER TABLE employees
DROP CONSTRAINT employees_department_id_fkey;

ALTER TABLE employees
ADD FOREIGN KEY (department_id)
REFERENCES departments(id)
ON DELETE CASCADE;

7. In the accounts table, remove an existing CHECK constraint that enforces balance >= 0.

ALTER TABLE accounts
DROP CONSTRAINT accounts_balance_check;

8. In the payments table, ensure that the combination of user_id and transaction_id is unique using an ALTER TABLE statement.

ALTER TABLE payments
ADD CONSTRAINT unique_payment UNIQUE (user_id, transaction_id);

Creating Table

Abirami Prabhakar — Sat, 28 Mar 2026 14:40:45 +0000

1. Create a table called students where each student has an id, name, and age. Ensure that the id uniquely identifies each student.

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    age INT
);

2. Create a table employees where name and email cannot be empty, but phone_number can be optional.

NOT NULL contraint is used to ensure that a attribute cannot be left empty

CREATE TABLE employees (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    phone_number VARCHAR(15)
);

3. Create a table users where both username and email must be unique across all records.

UNIQUE constaint is allow only unique values and no repeated values

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE,
    email VARCHAR(100) UNIQUE
);

*4. Create a table products where price must always be greater than 0 and stock cannot be negative.
*
DECIMAL datatype is used to keep records of money in detail and arthmetic operators are used to check certain values

CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    price DECIMAL CHECK (price > 0),
    stock INT CHECK (stock >= 0)
);

5. Create a table orders where status should default to 'pending' if no value is provided, and created_at should store the current timestamp automatically.

DEFAULT is used to fill any string/ value when a record has no input from user

CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    status VARCHAR(20) DEFAULT 'pending',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

6. Create a table accounts where account_number must be unique and not null balance must always be greater than or equal to 0

CREATE TABLE accounts (
    id SERIAL PRIMARY KEY,
    account_number VARCHAR(50) UNIQUE NOT NULL,
    balance DECIMAL CHECK (balance >= 0) 
);

7. Create a table enrollments where a student can enroll in multiple courses, but the combination of student_id and course_id must be unique.

CREATE TABLE enrollments (
    id SERIAL PRIMARY KEY,
    student_id INT UNIQUE, 
    course_id INT UNIQUE,   
);

8. Create two tables:
departments with id and name
employees with id, name, and department_id
Ensure that department_id in employees must exist in departments.

foreign key refernce from the employee table to the departments table as be used with constraint to ensure the presence of dept_id attribute in both table

CREATE TABLE departments (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100)
);

CREATE TABLE employees (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    department_id INT,
    FOREIGN KEY (department_id) REFERENCES departments(id)
);

9. When a department is deleted, all related employees are also deleted
When a department ID is updated, it reflects in the employees table

the previous foreign key contraint on the employee table as been dropped and a new constraint with refernces to dept_ id with ON DELETE CASCADE & ON UPDATE CASCADE as one cannot have two foreign constraint on the same table

ALTER TABLE employees
DROP CONSTRAINT employees_department_id_fkey;

ALTER TABLE employees
ADD FOREIGN KEY (department_id)
REFERENCES departments(id)
ON DELETE CASCADE
ON UPDATE CASCADE;

How DNS resolver is happening.

Abirami Prabhakar — Wed, 25 Mar 2026 16:50:48 +0000

Every time you type something like google.com into your browser, your device has one simple goal: find the IP address of that website so it can connect to the server. This process is called DNS resolution, and even though it sounds complex, it happens almost instantly behind the scenes.

It all starts with your device (the client). Before asking anyone else, it quickly checks its own cache—your browser cache, operating system cache, and sometimes even a local hosts file—to see if it already knows the IP address. If it does, great—no extra work needed. If not, it sends a request to a DNS resolver, which is usually managed by your ISP or a public DNS service.

Now the resolver takes over and does the heavy lifting. It doesn’t know the answer directly, so it starts asking around in a structured way. First, it contacts a root name server, which points it in the direction of the correct Top-Level Domain (TLD) server—like .com or .org. Then the resolver asks the TLD server, which responds with the address of the authoritative DNS server for that specific domain. Finally, the resolver queries this authoritative server, which returns the actual IP address.

Once the resolver gets the IP, it sends it back to your device and also stores it in its cache to make future requests faster. Now your browser finally has what it needs—it uses that IP address to establish a connection (using TCP/IP) and send an HTTP request to the server.

How a Request Travels from Client to Server

Abirami Prabhakar — Wed, 25 Mar 2026 16:44:23 +0000

We use the internet every day—scrolling, clicking, searching—but rarely stop to think about what actually happens behind that one simple action. Let’s say you type google.com or click a button on a website. That tiny action quietly triggers a full journey across the internet.

It all starts with your device, also called the client. The moment you enter a URL, your system doesn’t immediately know where to go. Computers don’t understand names—they understand IP addresses. So your device reaches out to DNS (Domain Name System) to translate that human-friendly name into an IP address. You can think of DNS as a contact list—it converts names into numbers.

Once the IP address is found, your browser prepares an HTTP request. This request contains things like the method (GET, POST), headers, and some metadata about what you’re asking for. Before it is sent, the request goes through the TCP/IP protocol stack, where a connection is established using the TCP three-way handshake to ensure reliable communication.

Now comes the interesting part—the request is broken into smaller chunks called packets. These packets travel across multiple networks, routers, and systems using IP routing. Each router along the way decides the best possible path, kind of like how maps choose the fastest route.

Eventually, these packets reach the server. The server reassembles them, understands the request, and processes it. This might involve fetching data from a database, running backend logic, or simply returning a static webpage.

Once done, the server sends back an HTTP response—again in packets. These travel all the way back to your device, where they are reassembled, and your browser finally renders the content on your screen.

Filter Assignments

Abirami Prabhakar — Wed, 25 Mar 2026 16:36:49 +0000

These are the basic building blocks used in SELECT queries to retrieve and filter data from a table. The FROM clause specifies which table the data is coming from, while the WHERE clause is used to apply conditions (constraints) to filter records before they are returned. Functions like COUNT(column_name) help count the total number of values in a column, and COUNT(DISTINCT column_name) is used to count only unique values. String functions such as LEFT(column_name, n) are useful for extracting characters from the beginning of a column value, often used in conditions to filter records based on starting letters or patterns. Together, these elements form the foundation of writing effective SQL queries for data retrieval and analysis.

1.Get all movies (films) that have a rental rate greater than $3.

SELECT title, rental_rate
FROM film
WHERE rental_rate > 3;

2.Get all movies that have a rental rate greater than $3 and a replacement cost less than $20.

SELECT title, rental_rate, replacement_cost
FROM film
WHERE rental_rate > 3 AND replacement_cost < 20;

3.Get all movies that are either rated as 'PG' or have a rental rate of $0.99.

SELECT title, rating, rental_rate
FROM film
WHERE rating = 'PG' OR rental_rate = 0.99;

4.Show the first 10 movies sorted by rental rate (highest first).

SELECT title, rental_rate
FROM film
ORDER BY rental_rate DESC
LIMIT 10;

5.Skip the first 5 movies and fetch the next 3 sorted by rental rate in ascending order.

SELECT title, rental_rate
FROM film
ORDER BY rental_rate ASC
OFFSET 5 LIMIT 3;

6.Get all movies with a rental duration between 3 and 7 days.

SELECT title, rental_duration
FROM film
WHERE rental_duration BETWEEN 3 AND 7;

7.Get all movies where the title starts with 'A' and ends with 'e'

SELECT title
FROM film
WHERE title LIKE 'A%e';

8.Find all customers who do not have an email address listed.

SELECT first_name, last_name
FROM customer
WHERE email IS NULL;

9.Find all movies released in 2006 with a rental rate of $2.99 or $3.99, and their title starts with 'S'. Display the top 5 results.SELECT title, rental_rate, release_year

FROM film
WHERE release_year = 2006 
  AND rental_rate IN (2.99, 3.99) 
  AND title LIKE 'S%'
LIMIT 5;

10.Display 10 customers after skipping the first 20, sorted alphabetically by last name.

SELECT first_name, last_name
FROM customer
ORDER BY last_name
LIMIT 10 OFFSET 20;

11.Get the top 5 movies with the highest replacement cost, skipping the most expensive one.

SELECT title, replacement_cost
FROM film
ORDER BY replacement_cost DESC
OFFSET 1 FETCH NEXT 5 ROWS ONLY;

12.Find all rentals that occurred between '2005-05-01' and '2005-06-01'.

SELECT rental_id, rental_date, customer_id
FROM rental
WHERE rental_date BETWEEN '2005-05-01' AND '2005-06-01';

13.Get all actors whose last names contain the letters "man".

SELECT first_name, last_name
FROM actor
WHERE last_name LIKE '%man%';

14.Find all movies where the special features are not listed (i.e.,
special_features is NULL).

SELECT title
FROM film
WHERE special_features IS NULL;

15.Find all movies where the rental duration is more than 7 days.

SELECT title, rental_duration
FROM film
WHERE rental_duration > 7;

16.Find the first 10 movies with a rental rate of $2.99 or $4.99, a rating of 'R', and a title containing the word "L".

SELECT title, rental_rate, rating
FROM film
WHERE rental_rate IN (2.99, 4.99) 
  AND rating = 'R' 
  AND title LIKE '%L%'
LIMIT 10;

17.Find all movies where the title starts with "A" or "B" and ends with "s".

SIMILAR TO is used in SQL for advanced pattern matching, especially in PostgreSQL. It is more powerful than LIKE because it allows multiple conditions using patterns like (A|B) for matching different options. While LIKE is good for simple searches, SIMILAR TO is useful when you need more flexible and complex text filtering in a single condition.

SELECT title
FROM film
WHERE title SIMILAR TO '(A|B)%s';

18.Find all movies where the title contains "Man", "Men", or "Woman".

SELECT title
FROM film
WHERE title SIMILAR TO '%(Man|Men|Woman)%';