🔧 What are Database Triggers?

Database triggers are special automated procedures in a database that are automatically executed when certain events occur on a table or view.

🧠 Example:

Imagine you have a table called Orders, and you want to automatically log every time an order is deleted.
You can create a DELETE trigger on the Orders table that inserts a message into a Log table whenever a row is deleted.

🔄 Types of Triggers:

CREATE TRIGGER log_delete
AFTER DELETE ON Orders
FOR EACH ROW
BEGIN
  INSERT INTO Log (action, timestamp)
  VALUES ('Order deleted', NOW());
END;

✅ Common Uses of Triggers:

• Data validation

• Audit logging

• Enforcing business rules

• Extending referential integrity

⚠️ Disadvantages:

• Can be hard to debug

• Might trigger other actions unexpectedly

• Can impact performance if overly complex

Docker Compose is a tool that lets you define and run multi-container Docker applications using a single configuration file. Instead of starting each container manually via the Docker CLI, you can describe all your services (like a web app, database, cache, etc.) in a docker-compose.yml file and run everything with a single command.

In short:

Docker Compose = Project config + Multiple containers + One command to run it all

Example: docker-compose.yml

version: '3.9'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/code
  redis:
    image: "redis:alpine"

This file:

• Builds and runs a local web app container

• Starts a Redis container from the official image

• Automatically networks the two containers

Common Commands:

docker-compose up        # Start all services in the foreground
docker-compose up -d     # Start in detached (background) mode
docker-compose down      # Stop and remove containers, networks, etc.

Benefits of Docker Compose:

✅ Easy setup for multi-service applications
✅ Version-controlled config (great for Git)
✅ Reproducible development environments
✅ Simple startup/shutdown of entire stacks

Typical Use Cases:

• Local development with multiple services (e.g., web app + DB)

• Integration testing with full stack

• Simple deployment workflows (e.g., via CI/CD)

A Prepared Statement is a programming technique, especially used when working with databases, to make SQL queries more secure and efficient.

1. How does a Prepared Statement work?

It consists of two steps:

1. Prepare the SQL query with placeholders
   Example in SQL:

SELECT * FROM users WHERE username = ? AND password = ?

• (Some languages use :username or other types of placeholders.)

• Bind parameters and execute
  The real values are bound later, for example:

$stmt->bind_param("ss", $username, $password);
$stmt->execute();

2. Advantages

✅ Protection against SQL injection:
User input is treated separately and safely, not directly inserted into the SQL string.

✅ Faster with repeated use:
The SQL query is parsed once by the database server and can be executed multiple times efficiently (e.g., in loops).

3. Example in PHP using MySQLi

$conn = new mysqli("localhost", "user", "pass", "database");
$stmt = $conn->prepare("SELECT * FROM users WHERE email = ?");
$stmt->bind_param("s", $email); // "s" stands for string
$email = "example@example.com";
$stmt->execute();
$result = $stmt->get_result();

In short:

A Prepared Statement separates SQL logic from user input, making it a secure (SQL Injection) and recommended practice when dealing with databases.

An Outer Join is a type of database join (commonly used in SQL) that returns records from one or both tables even if there’s no matching record in the other table.

Types of Outer Joins:

1. LEFT OUTER JOIN (or simply: LEFT JOIN):
   → Returns all records from the left table, and the matching ones from the right table.
   → If there’s no match, the result is filled with NULL values from the right table.

2. RIGHT OUTER JOIN (or: RIGHT JOIN):
   → Returns all records from the right table, and the matching ones from the left table.
   → If there’s no match, NULL is used for the left side.

3. FULL OUTER JOIN:
   → Returns all records from both tables, with NULL where no match exists on either side.

Example:

Suppose you have two tables:

• Customers

  CustomerID	Name
  1	Anna
  2	Bernd
  3	Clara

• Orders

  OrderID	CustomerID	Product
  101	2	Book
  102	4	Lamp

LEFT JOIN (Customers LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID)

PDO stands for PHP Data Objects and it's a database abstraction layer in PHP. It provides an object-oriented interface to access different types of databases—such as MySQL, PostgreSQL, or SQLite—without needing to change much of your code.

Key Features of PDO:

✅ Consistent API
Same code style regardless of which database you use.

✅ Prepared Statements
Helps prevent SQL injection via bound parameters:

$stmt = $pdo->prepare("SELECT * FROM users WHERE id = :id");
$stmt->execute(['id' => $userId]);

✅ Transactions Support
Great for use cases like banking systems or other operations that need rollback/commit.

✅ Exception-based Error Handling

$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

✅ Easy Database Switching
Switching from MySQL to PostgreSQL? Usually only the DSN and driver need to be changed.

Example: Connecting to MySQL with PDO

$dsn = 'mysql:host=localhost;dbname=testdb;charset=utf8mb4';
$user = 'root';
$pass = '';

try {
    $pdo = new PDO($dsn, $user, $pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Connected successfully!";
} catch (PDOException $e) {
    echo "Connection failed: " . $e->getMessage();
}

Summary:

PDO is the recommended way to work with databases in modern PHP applications—especially for its security, flexibility, and ease of use.

Transaction Control Language (TCL) is a subset of SQL used to manage transactions in a database. A transaction is a logical unit of work that may consist of one or more SQL statements—typically INSERT, UPDATE, or DELETE—that should be executed together.

TCL provides commands to ensure that transactions are properly completed or rolled back in case of errors.

Main TCL Commands:

BEGIN;

UPDATE account SET balance = balance - 100 WHERE account_id = 1;
UPDATE account SET balance = balance + 100 WHERE account_id = 2;

COMMIT;

→ Both updates are completed together. If an error occurs, you could use ROLLBACK to cancel both operations.

Note:

TCL commands only work in database systems that support transactions (e.g., PostgreSQL, Oracle, or MySQL with InnoDB).

Data Control Language (DCL) is a subset of SQL that focuses on managing access rights and permissions within a database. DCL commands are used to control who can do what in the database.

Main DCL Commands:

GRANT SELECT, INSERT ON Customers TO User123;
REVOKE INSERT ON Customers FROM User123;

Common Privileges:

• SELECT – Read data

• INSERT – Add new data

• UPDATE – Modify existing data

• DELETE – Remove data

• ALL – Grant all available privileges

Key Characteristics:

• DCL handles security and access control in the database.

• Typically used by a database administrator (DBA).

• Permissions can be granted at the table, column, or database level.

• DCL operations are often transaction-dependent, requiring a COMMIT to take effect.

Comparison with Other SQL Subsets:

• DDL (Data Definition Language) – Defines the database structure (e.g., tables)

• DML (Data Manipulation Language) – Works with the data itself (e.g., insert or update)

• TCL (Transaction Control Language) – Manages transactions (COMMIT, ROLLBACK)

• DCL (Data Control Language) – Manages permissions and user access

DQL stands for Data Query Language, and it's a subset of SQL (Structured Query Language). It is used specifically to query data from a database without modifying it.

Key Characteristics of DQL:

• Read-only: DQL is used to retrieve data, not to insert, update, or delete it.

• The primary command used is:

SELECT

Example:

SELECT name, birthdate FROM customers WHERE city = 'Berlin';

This command retrieves the names and birthdates of all customers living in Berlin — without changing any data.

DQL vs Other SQL Sub-languages:

💡 What is an Entity Manager?

An Entity Manager is a core component of ORM (Object-Relational Mapping) frameworks, especially in Java (JPA – Java Persistence API), but also in other languages like PHP (Doctrine ORM).

📦 Responsibilities of an Entity Manager:

1. Persisting:

   • Saves a new object (entity) to the database.

   • Example (Doctrine): $entityManager->persist($user);

2. Finding/Loading:

   • Retrieves an object by its ID or other criteria.

   • Example: $entityManager->find(User::class, 1);

3. Updating:

   • Tracks changes to objects and writes them to the database (usually via flush()).

4. Removing:

   • Deletes an object from the database.

   • Example: $entityManager->remove($user);

5. Managing Transactions:

   • Begins, commits, or rolls back transactions.

6. Handling Queries:

   • Executes custom queries, often using DQL (Doctrine Query Language) or JPQL.

🔁 Entity Lifecycle:

The Entity Manager tracks the state of entities:

• managed (being tracked),

• detached (no longer tracked),

• removed (marked for deletion),

• new (not yet persisted).

🛠 Example with Doctrine (PHP):

$user = new User();
$user->setName('Max Mustermann');

$entityManager->persist($user); // Mark for saving
$entityManager->flush();        // Write to DB

✅ Summary:

The Entity Manager is the central component for working with database objects — creating, reading, updating, deleting. It abstracts SQL and provides a clean, object-oriented way to interact with your data layer.

Doctrine DBAL (Database Abstraction Layer) is a PHP library that provides an abstraction layer for database access. It is part of the Doctrine project (a popular ORM for PHP), but it can be used independently of the ORM.

Purpose and Benefits of Doctrine DBAL:

Doctrine DBAL offers a unified API to interact with different databases (such as MySQL, PostgreSQL, SQLite, etc.) without writing raw SQL specific to each database system.

Key Features of Doctrine DBAL:

• Connection Management

• • Easily configure and manage connections to various database systems.

  • Supports connection pooling, transactions, and more.

• SQL Query Builder

• • Build SQL queries programmatically using an object-oriented API:

$qb = $conn->createQueryBuilder();
$qb->select('u.id', 'u.name')
   ->from('users', 'u')
   ->where('u.age > :age')
   ->setParameter('age', 18);
$stmt = $qb->executeQuery();

• Database Independence

  • The same code works with different database systems (e.g., MySQL, PostgreSQL) with minimal changes.

• Schema Management

  • Tools to create, update, and compare database schemas.

  • Useful for migrations and automation.

• Data Type Conversion

  • Automatically converts data between PHP types and database-native types.

use Doctrine\DBAL\DriverManager;

$conn = DriverManager::getConnection([
    'dbname' => 'test',
    'user' => 'root',
    'password' => '',
    'host' => 'localhost',
    'driver' => 'pdo_mysql',
]);

$result = $conn->fetchAllAssociative('SELECT * FROM users');

When to Use DBAL Instead of ORM:

You might choose DBAL without ORM if:

• You want full control over your SQL.

• Your project doesn't need complex object-relational mapping.

• You're working with a legacy database or custom queries.

Summary:

Doctrine DBAL is a powerful tool for clean, portable, and secure database access in PHP. It sits between raw PDO usage and a full-featured ORM like Doctrine ORM, making it ideal for developers who want abstraction and flexibility without the overhead of ORM logic.