Forem: s mathavi

PostgreSQL(Alternations)

s mathavi — Fri, 20 Mar 2026 09:12:09 +0000

-ALTER TABLE → modify existing table structure.
-Operations: add/drop column, change datatype, rename column/table, add/drop constraints.

Common ALTER TABLE Operations

1. Add a new column

ALTER TABLE Employee ADD COLUMN email VARCHAR(100);

2. Drop (remove) a column

ALTER TABLE Employee DROP COLUMN email;

3. Change datatype of a column

ALTER TABLE Employee ALTER COLUMN salary TYPE NUMERIC(12,2);

4. Rename a column

ALTER TABLE Employee RENAME COLUMN name TO full_name;

5. Add a constraint

ALTER TABLE Employee ADD CONSTRAINT salary_positive CHECK (salary > 0);

6. Drop a constraint

ALTER TABLE Employee DROP CONSTRAINT salary_positive;

7. Rename the table itself

ALTER TABLE Employee RENAME TO Staff;

This is the basic PostgreSQL...

See you soon in the next blog!....

PostgreSql(Filtering & Sorting)

s mathavi — Fri, 20 Mar 2026 09:01:03 +0000

Filtering (WHERE clause)

Filtering means → only certain rows are selected based on a condition.

SELECT name, salary
FROM Employee
WHERE salary > 55000;

Output:

name	salary
Priya	60000
Meena	58000
Arun	62000

Sorting (ORDER BY clause)

Sorting means → arrange rows in ascending (ASC) or descending (DESC) order.

SELECT name, salary
FROM Employee
ORDER BY salary DESC;

See you soon in the next topic!.......

PostgreSql(Aggregative Functions)

s mathavi — Fri, 20 Mar 2026 08:48:55 +0000

Aggregative Function:

Aggregate functions perform calculations on multiple rows and return a single result.

They’re essential for:

Summarizing data (e.g., total salary, average marks)
Analyzing trends (e.g., highest sales, number of employees per department)
Filtering grouped results using HAVING

#Common SQL Aggregate Functions:

SELECT SUM(salary) FROM Employee;
SELECT COUNT(*) FROM Employee;
SELECT MAX(salary) FROM Employee;
SELECT MIN(salary) FROM Employee;

Using Aggregate Functions with GROUP BY:

SELECT dept_id, AVG(salary)
FROM Employee
GROUP BY dept_id;

Filtering Groups with HAVING

SELECT dept_id, COUNT(*) AS emp_count
FROM Employee
GROUP BY dept_id
HAVING COUNT(*) > 5;

Shows only departments with more than 5 employees.

Bye.. bye..

PostgreSQL-constraints

s mathavi — Fri, 20 Mar 2026 07:38:28 +0000

Constraints:

Constraints are the backbone of reliable database design. They act like safety checks, ensuring that every piece of data stored is valid, consistent, and meaningful.

Types of Constraints

1.PRIMARY KEY

-Ensures each row has a unique identifier.
-No duplicates, no NULL values.

example:

emp_id SERIAL PRIMARY KEY

2.FOREIGN KEY

-Creates a relationship between two tables.
-Ensures values in one table match values in another.

example:

dept_id INT REFERENCES Department(dept_id)

3.UNIQUE

-Guarantees that all values in a column are distinct.

example:

email VARCHAR(150) UNIQUE

4. NOT NULL

-Prevents empty values in a column.

example:

name VARCHAR(100) NOT NULL

5.DEFAULT

-Assigns an automatic value if none is provided during insertion.

example:

status VARCHAR(20) DEFAULT 'Active'

6. CHECK

-Validates data against a condition.

example:

salary NUMERIC(10,2) CHECK (salary > 0)

Example table:

CREATE TABLE Employee (
    emp_id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE,
    dept_id INT REFERENCES Department(dept_id),
    salary NUMERIC(10,2) CHECK (salary > 0),
    status VARCHAR(20) DEFAULT 'Active'
);

Why Constraints Matter

-Data Integrity: Prevents invalid or duplicate entries.
-Consistency: Enforces business rules (e.g., salary must be positive).
-Relationships: Maintains links between tables.
-Reliability: Ensures queries always return valid data.

Next blog is Relationship(joins) in PostgreSql....

PostgreSql - Relationships(joins)

s mathavi — Fri, 20 Mar 2026 07:38:05 +0000

How to connect Two Database in innerjoin?
1.Most Important step is Create Extension.

CREATE EXTENSION dblink;

Example:

SELECT e.name, d.dept_name
FROM Employee e
JOIN dblink('dbname=department_db',
            'SELECT dept_id, dept_name FROM Department')
AS d(dept_id INT, dept_name TEXT)
ON e.department_id = d.dept_id

;

Same Database:

Example:

SELECT e.name, d.dept_name FROM Employee e INNER JOIN Department d ON e.dept_id = d.dept_id;

Now we Start ,

Tables Setup

Employee table:

emp_id	name	dept_id
1	Udaya	2
2	Mathavi	3
3	Kumar	1
4	Meena	NULL

Department table:

dept_id	dept_name
1	IT
2	Finance
3	HR
4	Marketing

INNER JOIN

SELECT e.name, d.dept_name
FROM Employee e
INNER JOIN Department d ON e.dept_id = d.dept_id;

Output:

name	dept_name
Udaya	Finance
Mathavi	HR
Kumar	IT

!..Only employees with valid department.

LEFT JOIN

SELECT e.name, d.dept_name
FROM Employee e
LEFT JOIN Department d ON e.dept_id = d.dept_id;

Output:

name	dept_name
Udaya	Finance
Priya	HR
Kumar	IT
Meena	NULL

!..All employees shown, even Meena (no department → NULL).

RIGHT JOIN

SELECT e.name, d.dept_name
FROM Employee e
RIGHT JOIN Department d ON e.dept_id = d.dept_id;

Output:

name	dept_name
Udaya	Finance
Priya	HR
Kumar	IT
NULL	Marketing

!..All departments shown, even Marketing (no employee → NULL).

FULL OUTER JOIN

SELECT e.name, d.dept_name
FROM Employee e
FULL OUTER JOIN Department d ON e.dept_id = d.dept_id;

Output:

name	dept_name
Udaya	Finance
Priya	HR
Kumar	IT
Meena	NULL
NULL	Marketing

!..Combines LEFT + RIGHT → all employees + all departments.

CROSS JOIN

SELECT e.name, d.dept_name
FROM Employee e
CROSS JOIN Department d;

Output:

name	dept_name
Udaya	IT
Udaya	Finance
Udaya	HR
Udaya	Marketing
Priya	IT
Priya	Finance

... (every combination)

!..Every employee paired with every department.

Our next blog is Aggregate Function....

postgreSQL - CRUD

s mathavi — Thu, 19 Mar 2026 20:52:04 +0000

why postgreSQL?

PostgreSQL is popular because it offers enterprise‑grade reliability, modern features, and zero licensing costs, making it the go‑to database for both small projects and large‑scale systems.

Steps
1.Open your terminal.
2.update package - sudo apt update
3.Install PostgreSQL and contrib packages - sudo apt install postgresql postgresql-contrib
4.Verify installation: - psql --version

Next Steps: Initialize and Use PostgreSQL

Switch to the postgres user - sudo -i -u postgres
Enter the PostgreSQL shell - psql Now the prompt like postgres=#

3.create database - CREATE DATABASE Employee_DB;
will actually be stored as employee_db.

4.list of database -\l

Drop query: drop database embloyee_db;

!...semicolon is important for each query.

5.Then connect - \c employee_db (Enter to which data we will use)
6.check connect - It is looking like this (embloyee_db=#)
7.create table - CREATE TABLE Employee ( emp_id SERIAL PRIMARY KEY, name VARCHAR(100), department_id INT, salary NUMERIC(10,2) );

SERIAL → auto number generate.
PRIMARY KEY → unique identity.
VARCHAR → text (length limit).
INT → whole number.
NUMERIC(10,2) → decimal number (money, salary).

8.If you want one more column in table we use Alter - ALTER TABLE Employee ADD COLUMN email VARCHAR(100);

9.give Default value for column automatic assign value - ALTER TABLE Employee ADD COLUMN bonus INT DEFAULT 100;

10.Column name changing - ALTER TABLE Employee RENAME COLUMN department_id TO dept_id;

11.drop column - ALTER TABLE EMPLOYEE DROP COLUMN bonus;
!!..if we drop one column we lose all the columns datas so use it carefully.

12.Table list - \dl

13.Table Strucuture - \d table_name;

14.Table view - SELECT * FROM Employee;

15.Values Inserting - INSERT INTO Employee(name,department_id,salary,email)VALUES('udaya',2,msudaya@gmail.com,80000,);

16.update - UPDATE Employee SET department_id = 3 WHERE emp_id = 1;
17.delete ROW - DELETE FROM Employee WHERE emp_id = 1;

Next blog we will discuss about constraints,Relationships(joins),Aggregate Function,Filtering & Sorting,Table alternations.....

see u soon...!!!!

Part-4 Functional Interface(Supplier)

s mathavi — Tue, 03 Mar 2026 09:32:28 +0000

Supplier:

A functional interface in java.util.function.
Represents a value provider: it returns a value but takes no input.

Core method:

T get()

Key Characteristics:

Opposite of Consumer:

Consumer → takes input, no return.
Supplier → no input, returns output.

Often used for lazy initialization, default values, or generating data (like random numbers, timestamps, IDs).

Example: Basic Supplier

import java.util.function.Supplier;
public class SupplierDemo {
    public static void main(String[] args) {

        // Supplier that generates a random number
        Supplier<Double> randomSupplier = () -> Math.random();

        // Each call to get() produces a new value
        System.out.println("Random 1: " + randomSupplier.get());
        System.out.println("Random 2: " + randomSupplier.get());
    }
}

Example: Supplier for Default Value

import java.util.function.Supplier;

public class DefaultValueDemo {
    public static void main(String[] args) {

        Supplier<String> defaultName = () -> "Unknown User";

        String name = null;
        String finalName = (name != null) ? name : defaultName.get();

        System.out.println("Name: " + finalName); // Output: Name: Unknown User
    }
}

Specialized Suppliers:

Java also provides primitive-specialized suppliers:

IntSupplier → returns int.
LongSupplier → returns long.
DoubleSupplier → returns double.

Example:

import java.util.function.IntSupplier;

public class IntSupplierDemo {
    public static void main(String[] args) {
        IntSupplier diceRoll = () -> (int)(Math.random() * 6) + 1;
        System.out.println("Dice rolled: " + diceRoll.getAsInt());
    }
}

Thanks for reading — talk to you soon.

Part-4 Functional Interface(Function)

s mathavi — Tue, 03 Mar 2026 09:09:17 +0000

Function:

A functional interface in java.util.function.
Represents a transformation: takes an input of type T and produces an output of type R.

Core Method:

R apply(T t)

Extra Methods in Function:

Function is more powerful than Consumer because it supports chaining both before and after.

1. andThen(Function after)
First applies the current function, then applies the after function on the result.

Function<String, Integer> lengthFinder = str -> str.length();
Function<Integer, Integer> square = n -> n * n;

Function<String, Integer> lengthSquared = lengthFinder.andThen(square);

System.out.println(lengthSquared.apply("Java")); // 16

2. compose(Function before)

First applies the before function, then applies the current function.

Function<Integer, Integer> square = n -> n * n;
Function<Integer, String> toString = n -> "Result: " + n;

Function<Integer, String> squareThenString = toString.compose(square);

System.out.println(squareThenString.apply(5)); // Result: 25

Example for Compose

import java.util.function.Function;

public class FunctionOrderDemo {
    public static void main(String[] args) {

        Function<Integer, Integer> add2 = n -> n + 2;
        Function<Integer, Integer> multiply3 = n -> n * 3;

        // andThen → current first, then after
        System.out.println(add2.andThen(multiply3).apply(5));  
        // (5 + 2) * 3 = 21

        // compose → before first, then current
        System.out.println(add2.compose(multiply3).apply(5));  
        // (5 * 3) + 2 = 17
    }
}

Why not just use andThen always?

-If you always want current → after, andThen is enough.
-But sometimes you need the other order (before → current).

Example:

-You want to preprocess input before applying your main function.
-That’s when compose is useful.

I think it is useful to everyone see u Soon....

Part-3 Functional Interface (Consumer)

s mathavi — Tue, 03 Mar 2026 08:04:53 +0000

Consumer:

Consumer is an interface in java.
A functional interface in java.util.function.
Represents an operation that takes one input and returns nothing.

Core method:
void accept(T t)

Extra Methods in Consumer:
andThen(Consumer after)

Chains two Consumers together.
First executes the current Consumer, then executes the after Consumer.

Consumer<String> print = s -> System.out.println(s);
Consumer<String> printUpper = s -> System.out.println(s.toUpperCase());

Consumer<String> combined = print.andThen(printUpper);

combined.accept("hello");
// Output:
// hello
// HELLO

Specialized Consumers:
Java also provides specialized versions of Consumer for different use cases:
BiConsumer<T,U>
-Accepts two inputs, performs an action.

BiConsumer<String, Integer> printNameAge =
    (name, age) -> System.out.println(name + " is " + age + " years old");

printNameAge.accept("Ravi", 25);
// Output: Ravi is 25 years old

Primitive Consumer Interfaces:

Normal Consumer uses objects (like Integer), but when dealing with primitives like int, long, or double, that would cause unnecessary boxing/unboxing. So we have these specialized interfaces to handle primitives efficiently.

1. IntConsumer

Definition: A Consumer that takes an int and performs an action.

IntConsumer printSquare = n -> System.out.println(n * n);
printSquare.accept(5); // Output: 25

2. LongConsumer

Definition: A Consumer that takes a long and performs an action.

LongConsumer printHalf = l -> System.out.println(l / 2);
printHalf.accept(100L); // Output: 50

3. DoubleConsumer

Definition: A Consumer that takes a double and performs an action.

DoubleConsumer printDoubleValue = d -> System.out.println(d * 2);
printDoubleValue.accept(3.5); // Output: 7.0

See u Soon... we will meet at the next Amazing blog!.....

Part-2 Why Functional Interfaces Matter in Java 8(Predicate)

s mathavi — Wed, 21 Jan 2026 16:36:49 +0000

Now we will discussed about the part2 of Functional Interface.

1.Predicate:

A Predicate is a functional interface in Java (java.util.function.Predicate<T>).
It has exactly one abstract method:

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

Input: one value of type T
Output: true or false
Purpose: Used for condition checking.

Basic Example:

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;

        System.out.println(isEven.test(10)); // true
        System.out.println(isEven.test(7));  // false
    }
}

Predicate Chaining

Predicates can be combined:
-and() → both conditions must be true
-or() → at least one condition must be true
-negate() → opposite of condition

Example: Employee Age and Salary

class Employee {
    String name;
    int age;
    double salary;
    Employee(String n, int a, double s) { name = n; age = a; salary = s; }
}

Predicate<Employee> isAdult = e -> e.age > 18;
Predicate<Employee> highSalary = e -> e.salary > 50000;

Predicate<Employee> eligible = isAdult.and(highSalary);

System.out.println(eligible.test(new Employee("Ravi", 25, 60000))); // true
System.out.println(eligible.test(new Employee("Anu", 17, 70000)));  // false

Negate Condition


Predicate<Integer> isEven = n -> n % 2 == 0;
Predicate<Integer> isOdd = isEven.negate();

System.out.println(isOdd.test(5)); // true
System.out.println(isOdd.test(8)); // false

Negate turns even check → odd check.

We’ll continue exploring more Java concepts in the next blog. See you soon!

Why Functional Interfaces Matter in Java 8(Part-1:MethodReference)

s mathavi — Tue, 20 Jan 2026 17:25:30 +0000

A functional interface in Java is an interface that has only one abstract method, making it suitable for use with lambda expressions and method references (introduced in Java 8).

Use @_FunctionalInterface_ to ensure only one abstract method (annotation is optional).
Enable clean, concise code using lambdas and method references.

Meaning of Method Reference

A method reference is simply a shortcut syntax for a lambda expression.
When a lambda expression is only calling an existing method, instead of writing the full lambda, you can directly refer to that method.

Syntax looks like:

ClassName::staticMethodName
objectReference::instanceMethodName
ClassName::new (for constructors)

Types of MethodReference:

Example 1: Static Method Reference

import java.util.function.Function;
public class MethodRefDemo {
    public static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        // Lambda style
        Function<Integer, Integer> f1 = n -> MethodRefDemo.square(n);

        // Method reference style
        Function<Integer, Integer> f2 = MethodRefDemo::square;

        System.out.println(f1.apply(5)); // 25
        System.out.println(f2.apply(6)); // 36
    }
}

Example 2: Instance Method Reference

import java.util.function.Consumer;
public class MethodRefDemo2 {
    public void printMsg(String msg) {
        System.out.println(msg);
    }

    public static void main(String[] args) {
        MethodRefDemo2 obj = new MethodRefDemo2();

        // Lambda style
        Consumer<String> c1 = s -> obj.printMsg(s);

        // Method reference style
        Consumer<String> c2 = obj::printMsg;

        c1.accept("Hello Lambda");
        c2.accept("Hello Method Reference");
    }
}

Example 3: Constructor Reference

import java.util.function.Supplier;

class Employee {
    Employee() {
        System.out.println("Employee object created!");
    }
}

public class ConstructorRefDemo {
    public static void main(String[] args) {
        // Lambda style
        Supplier<Employee> s1 = () -> new Employee();

        // Constructor reference style
        Supplier<Employee> s2 = Employee::new;

        s1.get();
        s2.get();
    }
}

Multiple‑Parameter Constructor

import java.util.function.BiFunction;
class Product {
    String name;
    double price;

    Product(String name, double price) {
        this.name = name;
        this.price = price;
        System.out.println("Product created: " + name + " - " + price);
    }
}

public class ConstructorRefDemo3 {
    public static void main(String[] args) {
        // Lambda style
        BiFunction<String, Double, Product> f1 = (n, p) -> new Product(n, p);

        // Constructor reference style
        BiFunction<String, Double, Product> f2 = Product::new;

        f1.apply("Laptop", 75000.0);   // Product created: Laptop - 75000.0
        f2.apply("Phone", 25000.0);    // Product created: Phone - 25000.0
    }
}

Thanks for Reading......
That’s it for this blog—see you in the next java8 one!

Java-8 (Using lambdas with collections)

s mathavi — Mon, 19 Jan 2026 11:26:44 +0000

Why Collection In Lambda?

most of collections are used for store the data.
In java8 gives a lambda+stream so easy for handling.
we also have a concise code. Example 1: forEach with List

import java.util.*;
public class LambdaListDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Ravi", "Anu", "Kumar");

        // Lambda in forEach
        names.forEach(n -> System.out.println("Name: " + n));
    }
}

Example 2: Sorting with Comparator

import java.util.*;
public class LambdaSortDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Ravi", "Anu", "Kumar");

        // Sort using lambda comparator
        Collections.sort(names, (a, b) -> a.compareTo(b));

        System.out.println(names);
    }
}

Example 3: Using Lambdas with Map (Key-Value)

import java.util.*;
public class LambdaMapIteration {
    public static void main(String[] args) {
        Map<Integer, String> students = new HashMap<>();
        students.put(1, "Ravi");
        students.put(2, "Anu");
        students.put(3, "Kumar");

        // Iterate map using lambda
        students.forEach((id, name) -> System.out.println(id + " -> " + name));
    }
}

See you All...
we will meet in Another java8...