Distributed Database

A distributed database is a database in which data is stored across multiple physical locations (different computers or servers) that are connected through a network. Although the data is distributed, it appears to users as a single unified database.

Each site in a distributed database system can process local queries independently and also participate in global queries.

Example: A bank database where customer data is stored in different branch servers located in different cities.

Role of a Database Administrator (DBA)

A Database Administrator (DBA) is responsible for managing, maintaining, and securing the database system to ensure data availability, integrity, and performance.

• Database Installation & Configuration: Installs, configures, and upgrades database software.
• Data Security: Controls user access, permissions, and ensures data protection.
• Backup & Recovery: Performs regular backups and restores data during failures.
• Performance Monitoring: Optimizes database performance and handles tuning.
• Data Integrity: Ensures accuracy and consistency of stored data.

RAID (Redundant Array of Independent Disks) is a technology that combines multiple physical disks into a single logical unit to improve performance, reliability, and data availability.

• Techniques: Uses striping, mirroring, and parity.
• Goal: Faster data access and protection against disk failure

Relevance in Database

RAID is highly important in database systems because databases require high speed and data reliability.

• Ensures continuous database availability.
• Prevents data loss due to disk failure.
• Improves read/write performance.

Uses in Database

• RAID 1: Used for critical data (mirroring for safety).
• RAID 5: Used for balance of performance and storage efficiency.
• RAID 10: Used for high-performance databases.
• Backup Systems: Ensures data redundancy.

Is it Possible?

Yes, RAID is widely used in database systems.

• Implemented using hardware RAID controllers or software RAID.
• Common in servers, data centers, and enterprise systems.
• Essential for systems like banking, e-commerce, and cloud databases.

No. The Bellman-Ford Algorithm is not a Greedy Algorithm. It is a Dynamic Programming-based algorithm because it repeatedly relaxes all edges to find the shortest path from the source vertex to every other vertex.

Why?

• It performs Edge Relaxation for all edges exactly V − 1 times.
• A shorter path found in a later iteration can update a previously calculated distance.
• It works correctly even when the graph contains Negative Edge Weights.
• It can also detect Negative Weight Cycles.

Can All-Pairs Shortest Paths (with Negative Edge Weights) be computed in O(V³)?

Yes. The Floyd-Warshall Algorithm computes the All-Pairs Shortest Paths (APSP) in O(V³) time, provided that the graph does not contain a Negative Weight Cycle.

Key Points:

• Supports Negative Edge Weights.
• Time Complexity is O(V³).
• If a Negative Weight Cycle exists, the shortest path is undefined because the path cost can decrease indefinitely.
• The algorithm can detect a Negative Weight Cycle, but it cannot produce valid shortest paths in that case.

A Trigger is a special type of Stored Procedure in a Database Management System (DBMS) that automatically executes (fires) when a specified event occurs on a table or view. These events are typically INSERT, UPDATE, or DELETE operations.

When is a Trigger Used?

Triggers are used when certain actions need to be performed automatically after or before changes are made to database data.

Common uses of Triggers include:
• Automatically maintaining Audit Logs.
• Enforcing Business Rules and data integrity.
• Validating data before insertion or update.
• Automatically updating related tables.
• Preventing unauthorized or invalid data modifications.

Advantages of Trigger

• Executes automatically without user intervention.
• Maintains data consistency and integrity.
• Reduces repetitive application code.
• Helps implement complex business rules.
• Keeps an audit trail of database changes.
• Improves database security by controlling data modifications.

Example

A Trigger can automatically store the old employee salary in an Audit Table whenever the salary is updated.

ACID Properties in Database Transactions
ACID properties are a set of rules that ensure reliability, consistency, and integrity of a database during transactions. Each transaction must satisfy these four properties to maintain a correct database state.

1) Atomicity
Atomicity ensures that a transaction is treated as a single unit. Either all operations of the transaction are completed successfully, or none of them are applied. If any part fails, the entire transaction is rolled back, preventing partial updates.

2) Consistency
Consistency ensures that a transaction moves the database from one valid state to another valid state. All integrity constraints, rules, and conditions must be satisfied before and after the transaction.

3) Isolation
Isolation ensures that multiple transactions executed at the same time do not interfere with each other. Each transaction behaves as if it is executed independently, preventing problems like dirty reads or lost updates.

4) Durability
Durability guarantees that once a transaction is committed, its changes are permanently stored in the database. Even if the system crashes, the committed data will not be lost.

Answer:

$ ls -al

#include <bits/stdc++.h>
using namespace std;

int main() {
    string s;
    cout << "Enter String: ";
    cin >> s;
    int n = s.length();
    int start = 0, end = n - 1;

    while (start < end) {
        // XOR-based swapping without using extra storage
        s[start] ^= s[end];
        s[end] ^= s[start];
        s[start] ^= s[end];
        start++;
        end--;
    }

    cout << "Reverse String = " << s << endl;
    return 0;
}

Sample I/O:
Enter String: itjobqns
Reverse String = snqbojti
=== Code Execution Successful ===

🔗 Run Online: Reverse String

Given: R(w,x,y,z)

Functional Dependencies: F = { wx→yz, y→w, z→x }

Goal: Find all candidate keys (minimal superkeys).

Key idea: Find attribute sets whose closure gives {w,x,y,z} and are minimal.

Closures:

• (wx)+ = wx → yz ⇒ {w,x,y,z} ⇒ wx is a candidate key.
• (yz)+: y→w ⇒ add w, z→x ⇒ add x ⇒ {w,x,y,z} ⇒ yz is a candidate key.
• (wz)+: z→x ⇒ get x, now wx→yz ⇒ get y,z ⇒ {w,x,y,z} ⇒ wz is a candidate key.
• (xy)+: y→w ⇒ get w, now wx→yz ⇒ get y,z ⇒ {w,x,y,z} ⇒ xy is a candidate key.

Answer (Candidate Keys): {wx}, {xy}, {wz}, {yz}

Primary Key, Candidate Key, and Super Key (with Example)

In a relational database, keys are used to uniquely identify each record (tuple) in a relation.

Example Relation: STUDENT

STUDENT(StudentID, Name, Email, Phone)

• Super Key: A super key is a set of one or more attributes that can uniquely identify a record in a table.

Super Key Examples:
{StudentID}, {Email}, {StudentID, Name}, {StudentID, Phone}

• Candidate Key: A candidate key is a minimal super key. It uniquely identifies a record and has no unnecessary attributes.

Candidate Key Examples:
{StudentID}, {Email}

• Primary Key: A primary key is one candidate key chosen to uniquely identify records in the relation.

Primary Key Example:
StudentID

we have some elements :- {15, 47, 23, 34, 85, 97, 65, 89, 70}. And hash function is h(x) = x mod 7.
The hash values will be

The Hashing with chaining will be like −