Forem: Kiran Kumar

Triggers in SQL

Kiran Kumar — Thu, 02 Apr 2026 09:28:03 +0000

Triggers are SQL statements (or blocks of statements) that automatically execute when certain events occur on a table — typically INSERT, UPDATE, or DELETE. They’re tied to a table and fire either before or after the event, depending on how you define them.

Example

Table: Employees

CREATE TABLE Employees (
    EmpID INT PRIMARY KEY,
    Name VARCHAR(50),
    Salary DECIMAL(10,2)
);

Audit Log Table

CREATE TABLE SalaryLog (
    EmpID INT,
    OldSalary DECIMAL(10,2),
    NewSalary DECIMAL(10,2),
    ChangeDate TIMESTAMP
);

Trigger

CREATE TRIGGER log_salary_change
AFTER UPDATE ON Employees
FOR EACH ROW
BEGIN
   INSERT INTO SalaryLog (EmpID, OldSalary, NewSalary, ChangeDate)
   VALUES (OLD.EmpID, OLD.Salary, NEW.Salary, NOW());
END;

👉 Whenever a salary is updated in Employees, this trigger automatically records the change in SalaryLog.

Triggers = automatic execution based on events.
Events = INSERT, UPDATE, DELETE (sometimes BEFORE/AFTER).
Use cases: auditing, enforcing rules, maintaining consistency.
Caution: too many or complex triggers can hurt performance.

Atomic variables in java

Kiran Kumar — Tue, 24 Mar 2026 12:06:35 +0000

In short Atomic variables in Java are classes that provide lock-free, thread-safe operations on single variables.

Normally, when multiple threads access a shared variable (like a counter), you might use the synchronized keyword to prevent data corruption. Atomic variables provide a more efficient alternative.

The Problem:
Consider a simple counter: count++. Even though it looks like one step, the CPU actually performs three:

Read the current value.
Modify it (add 1).
Write it back.

If two threads do this at the exact same time, they might both read "5," both increment it to "6," and save "6." One update is lost.

Compare-And-Swap (CAS)
Atomic variables don't use "locks" (which can be slow because they make threads wait). Instead, they use a low-level CPU instruction called CAS

Compare: The thread checks if the current value is still what it expected.

Swap: If it matches, it updates the value. If it doesn't match (meaning another thread changed it), it fails and usually tries again.

Why use them?

They are generally faster than synchronized blocks because they avoid the overhead of "parking" and "waking up" threads.
You don't have to worry about manual locking or deadlocks.
They are perfect for small, specific updates to single values.

Find the second largest string by length in a sentence using Java 8

Kiran Kumar — Mon, 23 Mar 2026 11:16:59 +0000

import java.util.Arrays;
import java.util.Comparator;
import java.util.Optional;

public class SecondLargestString {
    public static void main(String[] args) {
        String sentence = "The quick brown fox jumps over the lazy dog";

        Optional<String> secondLargest = Arrays.stream(sentence.split("\\s+")) // 1. Split into words
            .distinct() // 2. Remove duplicates (e.g., "The" and "the" would be treated as distinct here unless lowercased first)
            .sorted(Comparator.comparingInt(String::length).reversed() // 3. Sort by length in descending order
                .thenComparing(Comparator.naturalOrder())) // 4. Optional: sort alphabetically for ties in length
            .skip(1) // 5. Skip the longest string
            .findFirst(); // 6. Get the next string (the second longest)

        if (secondLargest.isPresent()) {
            System.out.println("The second largest string is: " + secondLargest.get());
        } else {
            System.out.println("Could not find the second largest string.");
        }
    }
}