Lección 33 de 36 · Proyecto final: CRUD de tareas con SQLite✦ WebMCP implementado
Fase 3: el repositorio, interfaz y SQLite
10 min de lectura3 retos
El repositorio es el almacén de las tareas: el dominio dice qué se guarda y el repositorio dice dónde y cómo. En esta fase escribes dos: uno con SQLite para la app de verdad y otro en memoria para los tests y para practicar aquí mismo.
¿De dónde vienen los nombres?
QueryRow = query (consulta) + row (fila)
Lanza una consulta que devuelve como mucho una fila. Es tu $stmt->execute() + $stmt->fetch() de PDO.
Scan = scan (escanear, leer de arriba abajo)
Copia las columnas de la fila en tus variables, en orden. Es el fetch(PDO::FETCH_BOUND) con bindColumn(), o el list(...) = $fila.
ErrNoRows = Error + no rows (ninguna fila)
El error que da QueryRow(...).Scan() cuando la consulta no encuentra nada. En PHP, fetch() devuelve false.
Mutex = mutual exclusion (exclusión mutua)
Un candado: solo una goroutine a la vez entra en el trozo de código protegido (módulo 08).
En 4 ideas
1/4
El repositorio cumple la interfaz dominio.RepositorioTareassin escribir implements: basta con tener los cuatro métodos. En PHP sería class PdoTareaRepository implements TareaRepository.
Con database/sql, Exec es para INSERT/UPDATE/DELETE, QueryRow para una fila y Query para varias. En PHP, todo eso lo hace PDOStatement.
Al leer varias filas hay que cerrar con defer rows.Close() y mirar rows.Err() al final. PDO lo hace por ti dentro de fetchAll().
El repositorio traduce los errores de la base de datos a errores del dominio: sql.ErrNoRows se convierte en ErrTareaNoEncontrada envuelto con %w. En PHP: if ($fila === false) throw new TareaNoEncontrada().
1 · Una interfaz, dos almacenes
Un enchufe de la pared no sabe qué le vas a conectar: una lámpara, un cargador o una tostadora. Solo pide que la clavija encaje. La interfaz RepositorioTareas de la fase 2 es ese enchufe, y vamos a fabricar dos clavijas:
Repositorio
Dónde guarda
Para qué
repositorio.SQLite
El fichero tareas.db
La app de verdad, en local y en producción
repositorio.Memoria
Un map dentro del programa
Los tests (rápidos, sin disco) y los retos de esta web
Los casos de uso (fase 4) solo conocerán la interfaz, nunca cuál de los dos tienen enchufado. Es la inversión de dependencias que ya haces en Symfony o Laravel cuando el constructor pide un TareaRepository y el contenedor te da la clase concreta.
Equivalencia POO · PHP → Go
Así se traduce el «implements» de PHP:
PHP
Go
Quién lo ve
interface TareaRepository
type RepositorioTareas interface (en dominio)
Todos los paquetes del módulo
class PdoTareaRepository implements TareaRepository
type SQLite struct + sus 4 métodos (sin implements)
Quien importe repositorio
private PDO $pdo (propiedad privada)
db *sql.DB (minúscula)
Solo el paquete repositorio
public function __construct(PDO $pdo)
func NuevoSQLite(db *sql.DB) *SQLite
Cualquiera
El error de PHP «Class X contains abstract method…»
var _ dominio.RepositorioTareas = (*SQLite)(nil)
El compilador, al compilar el paquete
¿Por qué? · En PHP no existe
¿Por qué esa línea rara var _ dominio.RepositorioTareas = (*SQLite)(nil)? En PHP no hace falta
En PHP escribes implements TareaRepository y, si te falta un método, PHP se queja al cargar la clase. En Go no hay implements: un tipo cumple una interfaz cuando tiene sus métodos, y nadie lo comprueba hasta que lo usas como tal (módulo 05). Si el sitio donde lo usas está en otro paquete, el aviso llega tarde y lejos.
Esta línea fuerza la comprobación justo al lado del tipo. (*SQLite)(nil) es «un puntero a SQLite que vale nil»: no reserva nada y el _ lo tira. Solo sirve para que el compilador mire. Si te olvidas de Borrar, el error sale aquí mismo:
./main.go:18:27: cannot use (*Memoria)(nil) (value of type *Memoria) as RepositorioTareas value in variable declaration: *Memoria does not implement RepositorioTareas (missing method Borrar)
Es tu implements de PHP, escrito a mano y comprobado al compilar.
2 · El repositorio SQLite
Empezamos por guardar y buscar. Guardar hace un INSERT si la tarea es nueva (ID == 0) y un UPDATE si ya existe. Aquí el SQL va escrito a mano y con ?, igual que con PDO:
PHP 8.5pdo-tarea-repository.php
<?phpdeclare(strict_types=1);
namespace App\Infrastructure\Repository;
use App\Domain\{Tarea, TareaNoEncontrada, TareaRepository};
finalreadonlyclass PdoTareaRepository implements TareaRepository
{
publicfunction__construct(private \PDO $pdo) {}
publicfunctionguardar(Tarea $tarea): Tarea
{
if ($tarea->id === 0) {
$this->pdo->prepare("INSERT INTO tareas (titulo, prioridad, hecha, etiquetas, creada_en) VALUES (?, ?, ?, ?, ?)")
->execute([
$tarea->titulo,
$tarea->prioridad->value,
(int) $tarea->hecha,
implode(",", $tarea->etiquetas),
gmdate(DATE_ATOM),
]);
return$tarea->conId((int) $this->pdo->lastInsertId());
}
// ... UPDATE tareas SET ... WHERE id = ?return$tarea;
}
publicfunctionbuscarPorId(int $id): Tarea
{
$consulta = $this->pdo->prepare(
"SELECT id, titulo, prioridad, hecha, etiquetas FROM tareas WHERE id = ?"
);
$consulta->execute([$id]);
$fila = $consulta->fetch(\PDO::FETCH_ASSOC);
if ($fila === false) {
thrownewTareaNoEncontrada("buscar tarea {$id}");
}
return Tarea::desdeFila($fila);
}
}
Gosqlite.go
package repositorio
typeSQLitestruct {
db *sql.DB
}
funcNuevoSQLite(db *sql.DB) *SQLite {
return &SQLite{db: db}
}
var _ dominio.RepositorioTareas = (*SQLite)(nil)
func (r *SQLite) Guardar(t dominio.Tarea) (dominio.Tarea, error) {
etiquetas := strings.Join(t.Etiquetas, ",")
if t.ID == 0 {
res, err := r.db.Exec(
`INSERT INTO tareas (titulo, prioridad, hecha, etiquetas, creada_en) VALUES (?, ?, ?, ?, ?)`,
t.Titulo, int(t.Prioridad), boolAEntero(t.Hecha), etiquetas, time.Now().UTC().Format(time.RFC3339),
)
if err != nil {
return dominio.Tarea{}, fmt.Errorf("insertar tarea: %w", err)
}
// En PHP: $pdo->lastInsertId()
id, err := res.LastInsertId()
if err != nil {
return dominio.Tarea{}, fmt.Errorf("leer id nuevo: %w", err)
}
t.ID = int(id)
return t, nil
}
res, err := r.db.Exec(
`UPDATE tareas SET titulo = ?, prioridad = ?, hecha = ?, etiquetas = ? WHERE id = ?`,
t.Titulo, int(t.Prioridad), boolAEntero(t.Hecha), etiquetas, t.ID,
)
if err != nil {
return dominio.Tarea{}, fmt.Errorf("actualizar tarea %d: %w", t.ID, err)
}
// En PHP: $stmt->rowCount() === 0if n, _ := res.RowsAffected(); n == 0 {
return dominio.Tarea{}, fmt.Errorf("actualizar tarea %d: %w", t.ID, dominio.ErrTareaNoEncontrada)
}
return t, nil
}
func (r *SQLite) BuscarPorID(id int) (dominio.Tarea, error) {
var f fila
err := r.db.QueryRow(`SELECT id, titulo, prioridad, hecha, etiquetas FROM tareas WHERE id = ?`, id).
Scan(&f.ID, &f.Titulo, &f.Prioridad, &f.Hecha, &f.Etiquetas)
// En PHP: if ($fila === false) throw new TareaNoEncontrada();if errors.Is(err, sql.ErrNoRows) {
return dominio.Tarea{}, fmt.Errorf("buscar tarea %d: %w", id, dominio.ErrTareaNoEncontrada)
}
if err != nil {
return dominio.Tarea{}, fmt.Errorf("buscar tarea %d: %w", id, err)
}
return f.aTarea()
}
fila y aTarea() son lo que escribiste en el último reto de la fase 1: traducir números y texto a una Tarea. Y Scan(&f.ID, ...) recibe punteros (módulo 03) porque tiene que escribir en tus variables.
Para varias filas se usa Query, que devuelve un cursor, rows. Lo recorres con rows.Next() como un while ($fila = $stmt->fetch()):
Gomain.go
func (r *SQLite) Listar() ([]dominio.Tarea, error) {
rows, err := r.db.Query(`SELECT id, titulo, prioridad, hecha, etiquetas FROM tareas ORDER BY id`)
if err != nil {
returnnil, fmt.Errorf("listar tareas: %w", err)
}
// Devuelve la conexión al pool al salir, pase lo que pase.defer rows.Close()
// Vacío pero no nil: en JSON saldrá [] y no null (fase 5).
tareas := []dominio.Tarea{}
for rows.Next() {
var f fila
if err := rows.Scan(&f.ID, &f.Titulo, &f.Prioridad, &f.Hecha, &f.Etiquetas); err != nil {
returnnil, fmt.Errorf("leer fila: %w", err)
}
t, err := f.aTarea()
if err != nil {
returnnil, err
}
tareas = append(tareas, t)
}
// Next() da false al acabar... y también si algo falla a medias.if err := rows.Err(); err != nil {
returnnil, fmt.Errorf("listar tareas: %w", err)
}
return tareas, nil
}
¿Por qué? · En PHP no existe
¿Por qué defer rows.Close() y rows.Err()? Con fetchAll() de PHP no te preocupas
En PHP cada petición vive unos milisegundos: al acabar el script, PHP cierra la conexión y libera todo. Un descuido no dura mucho.
Un servidor de Go vive semanas y comparte un pool con pocas conexiones (con SQLite, una). rows tiene una conexión ocupada mientras lo recorres. Si un return a medias se salta el cierre, esa conexión no vuelve nunca al pool. Con la siguiente petición el programa se queda esperando para siempre. Por eso defer rows.Close() va justo después de comprobar el error de Query (módulo 06).
Y rows.Next() devuelve false tanto si se acabaron las filas como si se cortó la lectura por un error. Sin rows.Err() devolverías media lista como si fuera la lista entera, sin enterarte.
Borrar sigue el mismo patrón que el UPDATE: un DELETE y, si RowsAffected() da 0, la tarea no existía.
3 · De sql.ErrNoRows a ErrTareaNoEncontrada
El repositorio hace de traductor. La base de datos habla de «filas»; el dominio habla de «tareas». Si dejases salir sql.ErrNoRows, la web tendría que saber que debajo hay SQL. Por eso se cambia por dominio.ErrTareaNoEncontrada, envuelto con %w para añadir el contexto (qué id). El paquete database/sql sí funciona aquí, aunque sin driver:
Gomain.go
package main
import (
"database/sql""errors""fmt"
)
varErrTareaNoEncontrada = errors.New("tarea no encontrada")
// Hace como que la consulta no encontró la fila.funcconsultar(id int) error {
return sql.ErrNoRows
}
funcBuscarPorID(id int) error {
err := consultar(id)
if errors.Is(err, sql.ErrNoRows) {
// En PHP: throw new TareaNoEncontrada("buscar tarea $id");return fmt.Errorf("buscar tarea %d: %w", id, ErrTareaNoEncontrada)
}
return err
}
funcmain() {
err := BuscarPorID(7)
fmt.Println("mensaje:", err)
fmt.Println("¿err == ErrTareaNoEncontrada?", err == ErrTareaNoEncontrada)
fmt.Println("¿errors.Is(err, ErrTareaNoEncontrada)?", errors.Is(err, ErrTareaNoEncontrada))
}
4 · El repositorio en memoria
El segundo almacén guarda las tareas en un map[int]Tarea: el id es la clave. Es como apuntar en una pizarra en vez de en el archivador. Se borra al apagar, pero es instantáneo y perfecto para los tests.
Lleva un sync.Mutex (módulo 08) porque el servidor web atiende cada petición en su propia goroutine: dos peticiones a la vez podrían escribir en el map a la vez, y Go para el programa con fatal error: concurrent map writes.
Gomain.go
package main
import (
"errors""fmt""maps""slices""sync"
)
varErrTareaNoEncontrada = errors.New("tarea no encontrada")
typeTareastruct {
IDintTitulostringHechabool
}
typeRepositorioTareasinterface {
Guardar(t Tarea) (Tarea, error)
BuscarPorID(id int) (Tarea, error)
Listar() ([]Tarea, error)
Borrar(id int) error
}
typeMemoriastruct {
mu sync.Mutex
tareas map[int]Tarea
siguiente int
}
funcNuevoMemoria() *Memoria {
return &Memoria{tareas: map[int]Tarea{}, siguiente: 1}
}
var _ RepositorioTareas = (*Memoria)(nil)
func (m *Memoria) Guardar(t Tarea) (Tarea, error) {
m.mu.Lock()
defer m.mu.Unlock()
if t.ID == 0 {
// En PHP: el AUTOINCREMENT de la tabla
t.ID = m.siguiente
m.siguiente++
} elseif _, ok := m.tareas[t.ID]; !ok {
returnTarea{}, fmt.Errorf("actualizar tarea %d: %w", t.ID, ErrTareaNoEncontrada)
}
m.tareas[t.ID] = t
return t, nil
}
func (m *Memoria) BuscarPorID(id int) (Tarea, error) {
m.mu.Lock()
defer m.mu.Unlock()
t, ok := m.tareas[id]
if !ok {
returnTarea{}, fmt.Errorf("buscar tarea %d: %w", id, ErrTareaNoEncontrada)
}
return t, nil
}
func (m *Memoria) Listar() ([]Tarea, error) {
m.mu.Lock()
defer m.mu.Unlock()
tareas := make([]Tarea, 0, len(m.tareas))
// Un map no tiene orden: se recorre por id ordenado, como ORDER BY id.for _, id := range slices.Sorted(maps.Keys(m.tareas)) {
tareas = append(tareas, m.tareas[id])
}
return tareas, nil
}
func (m *Memoria) Borrar(id int) error {
m.mu.Lock()
defer m.mu.Unlock()
if _, ok := m.tareas[id]; !ok {
return fmt.Errorf("borrar tarea %d: %w", id, ErrTareaNoEncontrada)
}
delete(m.tareas, id)
returnnil
}
funcmain() {
// La variable es de tipo interfaz: no sabe qué almacén hay detrás.var repo RepositorioTareas = NuevoMemoria()
pan, _ := repo.Guardar(Tarea{Titulo: "Comprar pan"})
repo.Guardar(Tarea{Titulo: "Llamar al banco"})
pan.Hecha = true
repo.Guardar(pan)
repo.Borrar(2)
tareas, _ := repo.Listar()
fmt.Printf("%+v\n", tareas)
_, err := repo.BuscarPorID(2)
fmt.Println(err, "→", errors.Is(err, ErrTareaNoEncontrada))
}
Hora de practicar
Retos · 0/3 resueltos
Reto 1 de 3 · ✓ Resuelto
Guardar con autoincremento
Completa Guardar(t Tarea) (Tarea, error) del repositorio en memoria: si t.ID es 0, dale el siguiente id (empieza en 1) y guárdala; si ya tiene id y existe, sustitúyela; si tiene id y no existe, devuelve un error que envuelva ErrTareaNoEncontrada. Es el INSERT con AUTOINCREMENT + UPDATE del guardar() de tu repositorio PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Tres caminos: t.ID == 0 (dale m.siguiente y súmale 1), el id existe (lo sabes con el comma ok_, ok := m.tareas[t.ID], módulo 04) o no existe (fmt.Errorf("...: %w", ErrTareaNoEncontrada)).
Reto 2 de 3 · ✓ Resuelto
Buscar y borrar con su error
Completa BuscarPorID(id int) (Tarea, error) y Borrar(id int) error del repositorio en memoria. Si el id no existe, los dos devuelven un error envuelto con %w que lleve ErrTareaNoEncontrada y el id en el mensaje, por ejemplo buscar tarea 7: tarea no encontrada. Es el throw new TareaNoEncontrada("buscar tarea $id") de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.m.tareas[id] con una clave que no existe no falla: devuelve una Tarea vacía (el valor cero, módulo 04). Usa el comma ok (t, ok := m.tareas[id]) y, si !ok, devuelve fmt.Errorf("buscar tarea %d: %w", id, ErrTareaNoEncontrada).
Reto 3 de 3 · ✓ Resuelto
Listar en orden y sin sorpresas
Completa Listar() ([]Tarea, error): devuelve las tareas ordenadas por id, una lista vacía []Tarea{} (no nil) si no hay ninguna, y copias de las etiquetas, para que quien cambie la lista no cambie lo guardado. Es tu SELECT ... ORDER BY id + fetchAll() de PHP, que siempre devuelve un array.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Tres trampas de módulos anteriores: var tareas []Tarea es nil (usa make([]Tarea, 0, len(m.tareas))), un map se recorre en orden aleatorio (slices.Sorted(maps.Keys(m.tareas))) y copiar una Tarea no copia su slice (slices.Clone).
Resumen
Lo que te llevas de esta lección
Un tipo cumple una interfaz por tener sus métodos, y var _ Interfaz = (*Tipo)(nil) lo comprueba al compilar (en PHP, implements).
Exec para escribir, QueryRow(...).Scan(&...) para una fila y Query + rows.Next() para varias (en PHP, execute(), fetch() y el while).
defer rows.Close() justo tras el Query y rows.Err() al final (en PHP lo hace fetchAll() y el fin del script).
sql.ErrNoRows se traduce a ErrTareaNoEncontrada con %w, y se mira con errors.Is, nunca con == (en PHP, fetch() === false y throw).
El repositorio en memoria lleva un sync.Mutex y ordena las claves del map (en PHP no hace falta: una petición, un proceso).
Para recordarlo: «Abre, Cierra, Pregunta»
AAbre rows, err := db.Query(...)
CCierra defer rows.Close()
PPregunta rows.Err()
Cada vez que leas varias filas: Abres el cursor, dejas programado que se Cierre y, al terminar el bucle, Preguntas si hubo error.