Patrón DAO (Data Access Object)

from abc import ABC, abstractmethod
from dataclasses import dataclass


@dataclass(frozen=True)
class Alumno:
    id: int
    nombre: str
    ciclo: str


class AlumnoDao(ABC):
    """El DAO: todas las operaciones con los alumnos guardados, sin decir dónde se guardan."""
    @abstractmethod
    def insertar(self, a): ...

    @abstractmethod
    def buscar_por_id(self, id): ...

    @abstractmethod
    def listar_por_ciclo(self, ciclo): ...

    @abstractmethod
    def borrar(self, id): ...


class AlumnoDaoMemoria(AlumnoDao):
    """Una implementación en memoria, para probar. La de la base de datos cumple la misma interfaz."""
    def __init__(self):
        self._tabla = {}

    def insertar(self, a):
        if a.id in self._tabla:
            raise KeyError(f"ya existe el alumno {a.id}")
        self._tabla[a.id] = a

    def buscar_por_id(self, id):
        return self._tabla.get(id)

    def listar_por_ciclo(self, ciclo):
        return [a for _, a in sorted(self._tabla.items()) if a.ciclo == ciclo]

    def borrar(self, id):
        return self._tabla.pop(id, None) is not None


class Secretaria:
    """La lógica de la aplicación usa el DAO por su interfaz: aquí no hay ni una línea de SQL."""
    def __init__(self, dao):
        self._dao = dao

    def matricular(self, id, nombre, ciclo):
        try:
            self._dao.insertar(Alumno(id, nombre, ciclo))
            print(f"Matriculado: {nombre} en {ciclo}")
        except KeyError as e:
            print(f"No se puede matricular a {nombre}: {e.args[0]}")

    def listar(self, ciclo):
        print(f"Alumnos de {ciclo}: {', '.join(a.nombre for a in self._dao.listar_por_ciclo(ciclo))}")

    def ficha(self, id):
        a = self._dao.buscar_por_id(id)
        print(f"#{a.id} {a.nombre} ({a.ciclo})" if a else f"No existe el alumno {id}")


s = Secretaria(AlumnoDaoMemoria())       # con un DAO de sqlite3 funcionaría igual
s.matricular(1, "Ana", "DAM")
s.matricular(2, "Luis", "DAW")
s.matricular(3, "Marta", "DAM")
s.matricular(2, "Pablo", "DAM")
s.listar("DAM")
s.ficha(2)
s.ficha(9)

/** Una implementación en memoria del DAO de alumnos. La de la base de datos tendría los mismos métodos. */
class AlumnoDaoMemoria {
    #tabla = new Map();

    insertar(a) {
        if (this.#tabla.has(a.id)) throw new Error(`ya existe el alumno ${a.id}`);
        this.#tabla.set(a.id, a);
    }

    buscarPorId(id) { return this.#tabla.get(id) ?? null; }

    listarPorCiclo(ciclo) {
        return [...this.#tabla.values()].sort((x, y) => x.id - y.id).filter((a) => a.ciclo === ciclo);
    }

    borrar(id) { return this.#tabla.delete(id); }
}

/** La lógica de la aplicación usa el DAO: aquí no hay ni una línea de SQL. */
class Secretaria {
    constructor(dao) { this.dao = dao; }

    matricular(id, nombre, ciclo) {
        try {
            this.dao.insertar({ id, nombre, ciclo });
            console.log(`Matriculado: ${nombre} en ${ciclo}`);
        } catch (e) {
            console.log(`No se puede matricular a ${nombre}: ${e.message}`);
        }
    }

    listar(ciclo) {
        console.log(`Alumnos de ${ciclo}: ${this.dao.listarPorCiclo(ciclo).map((a) => a.nombre).join(", ")}`);
    }

    ficha(id) {
        const a = this.dao.buscarPorId(id);
        console.log(a ? `#${a.id} ${a.nombre} (${a.ciclo})` : `No existe el alumno ${id}`);
    }
}

const s = new Secretaria(new AlumnoDaoMemoria());   // con un DAO de MySQL funcionaría igual
s.matricular(1, "Ana", "DAM");
s.matricular(2, "Luis", "DAW");
s.matricular(3, "Marta", "DAM");
s.matricular(2, "Pablo", "DAM");
s.listar("DAM");
s.ficha(2);
s.ficha(9);

using System;
using System.Collections.Generic;
using System.Linq;

record Alumno(int Id, string Nombre, string Ciclo);

// El DAO: todas las operaciones con los alumnos guardados, sin decir dónde se guardan.
interface IAlumnoDao {
    void Insertar(Alumno a);
    Alumno? BuscarPorId(int id);
    List<Alumno> ListarPorCiclo(string ciclo);
    bool Borrar(int id);
}

// Una implementación en memoria, para probar. La de la base de datos cumple la misma interfaz.
class AlumnoDaoMemoria : IAlumnoDao {
    private readonly SortedDictionary<int, Alumno> tabla = new();

    public void Insertar(Alumno a) {
        if (tabla.ContainsKey(a.Id)) throw new InvalidOperationException(
quot;ya existe el alumno {a.Id}");
        tabla[a.Id] = a;
    }

    public Alumno? BuscarPorId(int id) => tabla.GetValueOrDefault(id);
    public List<Alumno> ListarPorCiclo(string ciclo) => tabla.Values.Where(a => a.Ciclo == ciclo).ToList();
    public bool Borrar(int id) => tabla.Remove(id);
}

// La lógica de la aplicación usa el DAO por su interfaz: aquí no hay ni una línea de SQL.
class Secretaria {
    private readonly IAlumnoDao dao;
    public Secretaria(IAlumnoDao dao) => this.dao = dao;

    public void Matricular(int id, string nombre, string ciclo) {
        try {
            dao.Insertar(new Alumno(id, nombre, ciclo));
            Console.WriteLine(
quot;Matriculado: {nombre} en {ciclo}");
        } catch (InvalidOperationException e) {
            Console.WriteLine(
quot;No se puede matricular a {nombre}: {e.Message}");
        }
    }

    public void Listar(string ciclo) =>
        Console.WriteLine(
quot;Alumnos de {ciclo}: {string.Join(", ", dao.ListarPorCiclo(ciclo).Select(a => a.Nombre))}");

    public void Ficha(int id) {
        var a = dao.BuscarPorId(id);
        Console.WriteLine(a != null ? 
quot;#{a.Id} {a.Nombre} ({a.Ciclo})" : 
quot;No existe el alumno {id}");
    }
}

class Program {
    static void Main() {
        var s = new Secretaria(new AlumnoDaoMemoria());   // con un DAO de ADO.NET funcionaría igual
        s.Matricular(1, "Ana", "DAM");
        s.Matricular(2, "Luis", "DAW");
        s.Matricular(3, "Marta", "DAM");
        s.Matricular(2, "Pablo", "DAM");
        s.Listar("DAM");
        s.Ficha(2);
        s.Ficha(9);
    }
}

<?php
final class Alumno {
    public function __construct(public int $id, public string $nombre, public string $ciclo) {}
}

/** El DAO: todas las operaciones con los alumnos guardados, sin decir dónde se guardan. */
interface AlumnoDao {
    public function insertar(Alumno $a): void;
    public function buscarPorId(int $id): ?Alumno;
    public function listarPorCiclo(string $ciclo): array;
    public function borrar(int $id): bool;
}

/** Una implementación en memoria, para probar. La de PDO cumple la misma interfaz. */
class AlumnoDaoMemoria implements AlumnoDao {
    private array $tabla = [];

    public function insertar(Alumno $a): void {
        if (isset($this->tabla[$a->id])) throw new RuntimeException("ya existe el alumno {$a->id}");
        $this->tabla[$a->id] = $a;
        ksort($this->tabla);
    }

    public function buscarPorId(int $id): ?Alumno { return $this->tabla[$id] ?? null; }

    public function listarPorCiclo(string $ciclo): array {
        return array_values(array_filter($this->tabla, fn (Alumno $a) => $a->ciclo === $ciclo));
    }

    public function borrar(int $id): bool {
        if (!isset($this->tabla[$id])) return false;
        unset($this->tabla[$id]);
        return true;
    }
}

/** La lógica de la aplicación usa el DAO por su interfaz: aquí no hay ni una línea de SQL. */
class Secretaria {
    public function __construct(private AlumnoDao $dao) {}

    public function matricular(int $id, string $nombre, string $ciclo): void {
        try {
            $this->dao->insertar(new Alumno($id, $nombre, $ciclo));
            echo "Matriculado: $nombre en $ciclo\n";
        } catch (RuntimeException $e) {
            echo "No se puede matricular a $nombre: {$e->getMessage()}\n";
        }
    }

    public function listar(string $ciclo): void {
        $nombres = array_map(fn (Alumno $a) => $a->nombre, $this->dao->listarPorCiclo($ciclo));
        echo "Alumnos de $ciclo: ", implode(", ", $nombres), "\n";
    }

    public function ficha(int $id): void {
        $a = $this->dao->buscarPorId($id);
        echo $a ? "#{$a->id} {$a->nombre} ({$a->ciclo})" : "No existe el alumno $id", "\n";
    }
}

$s = new Secretaria(new AlumnoDaoMemoria());   // con un DAO de PDO funcionaría igual
$s->matricular(1, "Ana", "DAM");
$s->matricular(2, "Luis", "DAW");
$s->matricular(3, "Marta", "DAM");
$s->matricular(2, "Pablo", "DAM");
$s->listar("DAM");
$s->ficha(2);
$s->ficha(9);

import sqlite3


class AlumnoDaoSqlite(AlumnoDao):
    """La implementación de verdad: el SQL vive aquí y solo aquí."""
    def __init__(self, ruta):
        self._con = sqlite3.connect(ruta)

    def insertar(self, a):
        try:
            with self._con:
                self._con.execute("INSERT INTO alumno (id, nombre, ciclo) VALUES (?, ?, ?)", (a.id, a.nombre, a.ciclo))
        except sqlite3.IntegrityError:
            raise KeyError(f"ya existe el alumno {a.id}")          # el resto no ve sqlite3

    def listar_por_ciclo(self, ciclo):
        filas = self._con.execute("SELECT id, nombre, ciclo FROM alumno WHERE ciclo = ? ORDER BY id", (ciclo,))
        return [Alumno(*f) for f in filas]

// Con Node y mysql2: el SQL vive aquí y solo aquí
class AlumnoDaoMysql {
    constructor(pool) { this.pool = pool; }

    async insertar(a) {
        try {
            await this.pool.execute("INSERT INTO alumno (id, nombre, ciclo) VALUES (?, ?, ?)", [a.id, a.nombre, a.ciclo]);
        } catch (e) {
            if (e.code === "ER_DUP_ENTRY") throw new Error(`ya existe el alumno ${a.id}`);
            throw e;
        }
    }

    async listarPorCiclo(ciclo) {
        const [filas] = await this.pool.execute("SELECT id, nombre, ciclo FROM alumno WHERE ciclo = ? ORDER BY id", [ciclo]);
        return filas;
    }
}

// ADO.NET: el SQL y los parámetros viven aquí y solo aquí
public class AlumnoDaoSqlite : IAlumnoDao {
    private readonly string cadena;
    public AlumnoDaoSqlite(string cadena) => this.cadena = cadena;

    public List<Alumno> ListarPorCiclo(string ciclo) {
        using var con = new SqliteConnection(cadena);
        con.Open();
        using var cmd = con.CreateCommand();
        cmd.CommandText = "SELECT id, nombre, ciclo FROM alumno WHERE ciclo = $ciclo ORDER BY id";
        cmd.Parameters.AddWithValue("$ciclo", ciclo);
        using var lector = cmd.ExecuteReader();
        var r = new List<Alumno>();
        while (lector.Read()) r.Add(new Alumno(lector.GetInt32(0), lector.GetString(1), lector.GetString(2)));
        return r;
    }
    // Insertar, BuscarPorId y Borrar siguen la misma forma
}

<?php
/** La implementación con PDO: el SQL vive aquí y solo aquí. */
class AlumnoDaoPdo implements AlumnoDao {
    public function __construct(private PDO $pdo) {}

    public function insertar(Alumno $a): void {
        try {
            $st = $this->pdo->prepare("INSERT INTO alumno (id, nombre, ciclo) VALUES (?, ?, ?)");
            $st->execute([$a->id, $a->nombre, $a->ciclo]);
        } catch (PDOException $e) {
            if ($e->getCode() === "23000") throw new RuntimeException("ya existe el alumno {$a->id}");
            throw $e;
        }
    }

    public function listarPorCiclo(string $ciclo): array {
        $st = $this->pdo->prepare("SELECT id, nombre, ciclo FROM alumno WHERE ciclo = ? ORDER BY id");
        $st->execute([$ciclo]);
        return array_map(fn ($f) => new Alumno($f["id"], $f["nombre"], $f["ciclo"]), $st->fetchAll(PDO::FETCH_ASSOC));
    }
    // buscarPorId y borrar siguen la misma forma
}