Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 33 de 36 · Proyecto final: CRUD de tareas con SQLite ✦ WebMCP implementado

Fase 3: el repositorio, interfaz y SQLite

10 min de lectura 3 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.RepositorioTareas sin escribir implements: basta con tener los cuatro métodos. En PHP sería class PdoTareaRepository implements TareaRepository.

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:

RepositorioDónde guardaPara qué
repositorio.SQLiteEl fichero tareas.dbLa app de verdad, en local y en producción
repositorio.MemoriaUn map dentro del programaLos 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:

PHPGoQuién lo ve
interface TareaRepositorytype RepositorioTareas interface (en dominio)Todos los paquetes del módulo
class PdoTareaRepository implements TareaRepositorytype 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) *SQLiteCualquiera
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
<?php
declare(strict_types=1);

namespace App\Infrastructure\Repository;

use App\Domain\{Tarea, TareaNoEncontrada, TareaRepository};

final readonly class PdoTareaRepository implements TareaRepository
{
    public function __construct(private \PDO $pdo) {}

    public function guardar(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;
    }

    public function buscarPorId(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) {
            throw new TareaNoEncontrada("buscar tarea {$id}");
        }
        return Tarea::desdeFila($fila);
    }
}
Gosqlite.go
package repositorio

type SQLite struct {
    db *sql.DB
}

func NuevoSQLite(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() === 0
    if 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 {
        return nil, 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 {
            return nil, fmt.Errorf("leer fila: %w", err)
        }
        t, err := f.aTarea()
        if err != nil {
            return nil, err
        }
        tareas = append(tareas, t)
    }
    // Next() da false al acabar... y también si algo falla a medias.
    if err := rows.Err(); err != nil {
        return nil, 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"
)

var ErrTareaNoEncontrada = errors.New("tarea no encontrada")

// Hace como que la consulta no encontró la fila.
func consultar(id int) error {
    return sql.ErrNoRows
}

func BuscarPorID(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
}

func main() {
    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"
)

var ErrTareaNoEncontrada = errors.New("tarea no encontrada")

type Tarea struct {
    ID     int
    Titulo string
    Hecha  bool
}

type RepositorioTareas interface {
    Guardar(t Tarea) (Tarea, error)
    BuscarPorID(id int) (Tarea, error)
    Listar() ([]Tarea, error)
    Borrar(id int) error
}

type Memoria struct {
    mu        sync.Mutex
    tareas    map[int]Tarea
    siguiente int
}

func NuevoMemoria() *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++
    } else if _, ok := m.tareas[t.ID]; !ok {
        return Tarea{}, 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 {
        return Tarea{}, 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)
    return nil
}

func main() {
    // 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

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

Resumen

Lo que te llevas de esta lección

  1. Un tipo cumple una interfaz por tener sus métodos, y var _ Interfaz = (*Tipo)(nil) lo comprueba al compilar (en PHP, implements).
  2. Exec para escribir, QueryRow(...).Scan(&...) para una fila y Query + rows.Next() para varias (en PHP, execute(), fetch() y el while).
  3. defer rows.Close() justo tras el Query y rows.Err() al final (en PHP lo hace fetchAll() y el fin del script).
  4. sql.ErrNoRows se traduce a ErrTareaNoEncontrada con %w, y se mira con errors.Is, nunca con == (en PHP, fetch() === false y throw).
  5. 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.