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 31 de 36 · Proyecto final: CRUD de tareas con SQLite ✦ WebMCP implementado

Fase 1: el esquema en SQLite y las migraciones

9 min de lectura 3 retos

Empieza el proyecto final: una app de tareas de verdad, con base de datos, web y despliegue. En esta primera fase montas las carpetas del proyecto, eliges SQLite como base de datos y escribes las migraciones que crean la tabla tareas.

¿De dónde vienen los nombres?

database/sql = SQL = Structured Query Language (lenguaje de consultas estructurado)
El paquete de la biblioteca estándar para hablar con cualquier base de datos SQL. Es tu PDO: una sola API y un driver por cada motor.
cgo = C + Go
La herramienta que deja a un programa de Go llamar a código escrito en C. Muy útil, pero obliga a tener un compilador de C. Por eso aquí usamos un SQLite sin cgo.
Exec = execute (ejecutar)
Ejecuta una sentencia que no devuelve filas (CREATE, INSERT, UPDATE). Es el $pdo->exec() de PHP.
//go:embed = embed (incrustar, empotrar)
Una directiva que mete ficheros dentro del binario al compilar. En PHP no existe: allí subes la carpeta migraciones/ junto al código.
En 4 ideas
1/4

El proyecto se reparte en carpetas por capa: internal/dominio, internal/repositorio, internal/casosdeuso, internal/web y el arranque en cmd/tareas/main.go. Es tu src/Domain, src/Infrastructure y public/index.php de un PHP con DDD.

1 · El plan: seis fases y una carpeta por capa

Hasta ahora has visto el lenguaje pieza a pieza. Ahora toca montar algo entero. Piensa en una casa: primero los cimientos (la base de datos), luego las paredes (el dominio), las tuberías (el repositorio), las habitaciones (los casos de uso), la puerta de la calle (la web) y por último la mudanza (el despliegue).

  1. Fase 1: el esquema en SQLite y las migraciones (esta lección).
  2. Fase 2: el dominio, la entidad Tarea y sus reglas.
  3. Fase 3: el repositorio, una interfaz con dos versiones: SQLite y en memoria.
  4. Fase 4: los casos de uso: crear, listar, completar y borrar.
  5. Fase 5: controladores y vistas con net/http y html/template.
  6. Fase 6: tests, apagado limpio y despliegue con Docker.

Cada fase parte del código de la anterior. Así queda el proyecto cuando acabes:

tareas/
├── go.mod                       ← el composer.json
├── go.sum                       ← el composer.lock
├── cmd/tareas/main.go           ← el public/index.php: arranca todo
├── internal/
│   ├── dominio/                 ← Tarea, Prioridad, errores, la interfaz del repositorio
│   ├── repositorio/             ← SQLite, memoria y migraciones/*.sql
│   ├── casosdeuso/              ← CrearTarea, ListarTareas, CompletarTarea…
│   └── web/                     ← controladores y plantillas/*.html
└── Dockerfile
GoQué va dentroEn un PHP con DDD
cmd/tareas/main.goAbre la BD, cablea las piezas y arranca el servidorpublic/index.php + el contenedor de dependencias
internal/dominioLa entidad Tarea, sus reglas y sus erroressrc/Domain
internal/repositorioCómo se guardan las tareas (SQL)src/Infrastructure/Repository
internal/casosdeusoLo que la app sabe hacer, un caso por acciónsrc/Application (los services o handlers)
internal/webRutas, controladores y vistassrc/Infrastructure/Http + templates/
go.modNombre del módulo y dependenciascomposer.json

Equivalencia POO · PHP → Go

Cada carpeta es un paquete. El paquete hace de namespace y el import hace de use, con la ruta que empieza por el nombre del módulo (lo viste en el módulo 07).

PHPGoQuién lo ve
namespace App\Domain;package dominioEl nombre corto con el que lo llaman los demás
use App\Domain\Tarea;import "tareas/internal/dominio" y luego dominio.TareaCualquier paquete del mismo módulo
@internal en un docblock (solo un aviso)La carpeta internal/Solo el código del módulo tareas: el compilador lo impide al resto
Autoload PSR-4 de ComposerLa ruta de la carpeta es el nombre del importNo hay autoloader: lo resuelve el compilador

¿Por qué? · En PHP no existe

¿Por qué una carpeta internal/? En PHP no existe

En PHP, cualquiera que instale tu paquete con Composer puede hacer use de cualquier clase tuya, aunque sea un detalle interno. El @internal del docblock es solo un cartel de «no tocar»: nadie lo obliga.

En Go, lo que va dentro de internal/ solo lo puede importar el código que cuelga de la carpeta padre. Si otro módulo lo intenta, no compila:

package otro
    main.go:6:5: use of internal package tareas/internal/dominio not allowed

Así puedes cambiar tus tripas cuando quieras sin romperle el código a nadie: el cartel de «no tocar» lo pone el compilador.

2 · SQLite sin cgo: modernc.org/sqlite

SQLite es una base de datos que cabe en un fichero, por ejemplo tareas.db. No hay servidor que instalar ni usuario ni contraseña: es como una libreta en vez de una biblioteca entera. Para una app de tareas sobra.

Go trae el paquete database/sql, que es la API común (tu PDO). Para cada motor hace falta un driver. Para SQLite usamos modernc.org/sqlite:

$ mkdir tareas && cd tareas
$ go mod init tareas
$ go get modernc.org/sqlite
go: added modernc.org/sqlite v1.62.0
Gomain.go
import (
    "database/sql"

    // El _ importa el paquete solo por su efecto: se registra como driver "sqlite".
    // En PHP: la extensión pdo_sqlite activada en php.ini
    _ "modernc.org/sqlite"
)

// En PHP: $pdo = new PDO("sqlite:tareas.db");
db, err := sql.Open("sqlite", "tareas.db")

¿Por qué? · En PHP no existe

¿Por qué modernc.org/sqlite y no el driver más famoso? En PHP no te lo preguntas

En PHP, pdo_sqlite viene compilado dentro de PHP y ni lo piensas. En Go el driver es una dependencia más, y hay dos opciones:

  • github.com/mattn/go-sqlite3 usa cgo: mete el SQLite original, escrito en C. Necesitas un compilador de C en tu máquina y en el Docker, y compilar para otro sistema se complica.
  • modernc.org/sqlite es el mismo SQLite traducido a Go puro. Compila con un simple go build, también con CGO_ENABLED=0, y el binario funciona en una imagen de Docker casi vacía (lo harás en la fase 6).

Pagas un poco de velocidad a cambio de no pelearte con compiladores de C. Para un to-do, es un trato redondo.

3 · El esquema: la tabla tareas

La primera migración crea la tabla. Es SQL normal, el mismo que escribirías para PHP:

$ cat internal/repositorio/migraciones/001_crear_tareas.sql
CREATE TABLE tareas (
    id        INTEGER PRIMARY KEY AUTOINCREMENT,
    titulo    TEXT    NOT NULL,
    prioridad INTEGER NOT NULL DEFAULT 1,
    hecha     INTEGER NOT NULL DEFAULT 0,
    creada_en TEXT    NOT NULL
);

SQLite tiene muy pocos tipos. No hay BOOLEAN ni DATETIME: un sí/no se guarda como 0 o 1, y una fecha como texto (2026-11-17T10:00:00Z). Es como apuntar «hecha: 1» en una libreta: el que lee tiene que saber que 1 significa sí.

ColumnaTipo en SQLiteTipo en Go al leerEn la Tarea
idINTEGERint64ID int
tituloTEXTstringTitulo string
prioridadINTEGER (0, 1, 2)int64Prioridad Prioridad (el enum del módulo 04)
hechaINTEGER (0 o 1)int64Hecha bool
creada_enTEXTstringNo está: la pone el repositorio

Así que leer una fila es traducir. Primero llega una fila con números y texto, y luego la conviertes en una Tarea. Pulsa Ejecutar:

Gomain.go
package main

import "fmt"

// fila es una tarea tal y como sale de SQLite: solo números y texto.
type fila struct {
    ID        int64
    Titulo    string
    Prioridad int64
    Hecha     int64
}

func main() {
    filas := []fila{
        {ID: 1, Titulo: "Comprar pan", Prioridad: 2, Hecha: 0},
        {ID: 2, Titulo: "Llamar al banco", Prioridad: 1, Hecha: 1},
    }
    for _, f := range filas {
        // En PHP: $hecha = (bool) $fila['hecha'];
        hecha := f.Hecha == 1
        fmt.Printf("#%d %-16s prioridad=%d hecha=%t\n", f.ID, f.Titulo, f.Prioridad, hecha)
    }
}

4 · Migraciones: el historial de la base de datos

Una migración es un cambio en la base de datos guardado en un fichero, con un número delante para saber el orden. Es como el historial de obras de una casa: «1, poner los cimientos; 2, abrir una ventana». Una obra no se repite dos veces.

Nuestra segunda migración añade las etiquetas, guardadas como texto separado por comas (casa,urgente):

$ cat internal/repositorio/migraciones/002_etiquetas.sql
ALTER TABLE tareas ADD COLUMN etiquetas TEXT NOT NULL DEFAULT '';

Para saber cuáles ya están hechas, se apuntan en una tabla migraciones. El programa aplica en orden las que falten. Lo mismo que hacen Laravel o Phinx, escrito a mano:

PHP 8.5migrar.php
<?php
declare(strict_types=1);

// PHP 8.4+: PDO::connect() devuelve la subclase de SQLite
$pdo = PDO::connect("sqlite:" . __DIR__ . "/tareas.db");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$pdo->exec("CREATE TABLE IF NOT EXISTS migraciones (
    nombre TEXT PRIMARY KEY, aplicada_en TEXT NOT NULL)");

$ficheros = glob(__DIR__ . "/migraciones/*.sql");
sort($ficheros);

foreach ($ficheros as $fichero) {
    $nombre = basename($fichero);
    $consulta = $pdo->prepare("SELECT COUNT(*) FROM migraciones WHERE nombre = ?");
    $consulta->execute([$nombre]);
    if ((int) $consulta->fetchColumn() > 0) {
        continue;
    }
    $pdo->beginTransaction();
    try {
        $pdo->exec(file_get_contents($fichero));
        $pdo->prepare("INSERT INTO migraciones VALUES (?, datetime('now'))")
            ->execute([$nombre]);
        $pdo->commit();
    } catch (Throwable $e) {
        $pdo->rollBack();
        throw $e;
    }
}
Gobd.go
package repositorio

// Mete los .sql dentro del binario al compilar.
//go:embed migraciones/*.sql
var migracionesFS embed.FS

// Migrar aplica, en orden, las migraciones que falten.
func Migrar(db *sql.DB) error {
    _, err := db.Exec(`CREATE TABLE IF NOT EXISTS migraciones (
        nombre TEXT PRIMARY KEY, aplicada_en TEXT NOT NULL)`)
    if err != nil {
        return fmt.Errorf("crear tabla migraciones: %w", err)
    }
    nombres, err := fs.Glob(migracionesFS, "migraciones/*.sql")
    if err != nil {
        return err
    }
    slices.Sort(nombres)
    for _, nombre := range nombres {
        if err := aplicar(db, nombre); err != nil {
            return fmt.Errorf("migración %s: %w", nombre, err)
        }
    }
    return nil
}

func aplicar(db *sql.DB, nombre string) error {
    var n int
    err := db.QueryRow(`SELECT COUNT(*) FROM migraciones WHERE nombre = ?`, nombre).Scan(&n)
    if err != nil || n > 0 {
        return err
    }
    sqlMigracion, err := migracionesFS.ReadFile(nombre)
    if err != nil {
        return err
    }
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    // En PHP: el rollBack() del catch. Tras un Commit no hace nada.
    defer tx.Rollback()
    if _, err := tx.Exec(string(sqlMigracion)); err != nil {
        return err
    }
    _, err = tx.Exec(`INSERT INTO migraciones (nombre, aplicada_en) VALUES (?, datetime('now'))`, nombre)
    if err != nil {
        return err
    }
    return tx.Commit()
}

Fíjate en tres cosas que ya conoces: los errores se envuelven con %w (módulo 06), el defer tx.Rollback() hace de finally (módulo 06) y los ? son parámetros, igual que en prepare(): nunca se pega texto del usuario dentro del SQL.

¿Por qué? · En PHP no existe

¿Por qué //go:embed? En PHP no existe

En PHP despliegas una carpeta entera: el código, las vistas, las migraciones. Si al subir se te olvida migraciones/, la app arranca y falla más tarde, en producción.

Go entrega un solo binario (módulo 01). //go:embed migraciones/*.sql le dice al compilador: «copia estos ficheros dentro del programa». Si la carpeta no existe o está vacía, no compila. Y en el servidor no hace falta subir nada más que el binario.

Ojo: la línea //go:embed va pegada encima de la variable, sin espacio entre // y go. Si escribes // go:embed, es un comentario normal y no hace nada.

La lógica de «ordenar y saltarse las ya aplicadas» no necesita base de datos. Aquí la tienes con un map (que no tiene orden, módulo 02):

Gomain.go
package main

import (
    "fmt"
    "maps"
    "slices"
)

func main() {
    // Nombre del fichero → SQL. En el proyecto salen de migraciones/*.sql
    migraciones := map[string]string{
        "002_etiquetas.sql":    "ALTER TABLE tareas ADD COLUMN etiquetas TEXT NOT NULL DEFAULT '';",
        "001_crear_tareas.sql": "CREATE TABLE tareas (...);",
    }
    // Lo que ya está apuntado en la tabla migraciones.
    aplicadas := map[string]bool{"001_crear_tareas.sql": true}

    // Un map no tiene orden: primero se ordenan los nombres.
    for _, nombre := range slices.Sorted(maps.Keys(migraciones)) {
        if aplicadas[nombre] {
            fmt.Println("ya aplicada:", nombre)
            continue
        }
        fmt.Println("aplicando:", nombre)
        fmt.Println("   ", migraciones[nombre])
        aplicadas[nombre] = true
    }
}

5 · Abrir la base de datos y probarlo en local

La función Abrir va en el mismo paquete. Comprueba la conexión con Ping (como hacer una consulta tonta para ver si responde) y limita las conexiones a una, porque SQLite solo deja escribir a uno a la vez:

Gomain.go
// Abrir abre (o crea) el fichero SQLite.
func Abrir(ruta string) (*sql.DB, error) {
    db, err := sql.Open("sqlite", ruta)
    if err != nil {
        return nil, fmt.Errorf("abrir %s: %w", ruta, err)
    }
    // SQLite admite un solo escritor a la vez.
    db.SetMaxOpenConns(1)
    if err := db.Ping(); err != nil {
        db.Close()
        return nil, fmt.Errorf("conectar con %s: %w", ruta, err)
    }
    return db, nil
}

Para probarlo sin dejar ficheros por ahí, SQLite tiene una ruta especial: :memory:, una base de datos que vive solo mientras dura el programa. Es perfecta para los tests (módulo 07):

Gomain.go
func TestMigrarDosVeces(t *testing.T) {
    db, err := Abrir(":memory:")
    if err != nil {
        t.Fatal(err)
    }
    defer db.Close()
    // La segunda vez no debe hacer nada ni fallar.
    for range 2 {
        if err := Migrar(db); err != nil {
            t.Fatal(err)
        }
    }
}
$ go test ./internal/repositorio/
ok      tareas/internal/repositorio     0.022s

La pregunta que te vas a hacer

«Vale, pero… ¿y mis migraciones de Laravel o mi Doctrine?»

En Go no hay un ORM que lo haga todo, como Eloquent o Doctrine. Lo habitual es escribir SQL a mano (como aquí) y apoyarse en herramientas pequeñas para cada cosa:

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

De 0/1 a bool y vuelta

SQLite guarda hecha como 0 o 1. Completa HechaABool(n int64) bool (devuelve true solo si n es 1) y BoolAHecha(b bool) int64 (devuelve 1 o 0). Es el (bool) $fila['hecha'] y el (int) $hecha de 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. Una carpeta por capa dentro de internal/ y el arranque en cmd/tareas/main.go (en PHP, src/Domain, src/Infrastructure y public/index.php).
  2. internal/ lo protege el compilador (en PHP, @internal es solo un aviso).
  3. database/sql + modernc.org/sqlite es tu PDO + pdo_sqlite, sin cgo y sin compilador de C.
  4. SQLite guarda hecha como 0/1: se traduce con f.Hecha == 1 (en PHP, (bool) $fila['hecha']).
  5. Migraciones numeradas con ceros, aplicadas en orden, apuntadas en una tabla y metidas en el binario con //go:embed (en PHP, la carpeta de Laravel o Phinx).

Para recordarlo: «Cero, Orden, Apunta»

CCeros
001_crear_tareas.sql
OOrden
slices.Sort(nombres)
AApunta
INSERT INTO migraciones

Las tres reglas de una migración: nombre con Ceros delante, se aplican en Orden y cada una se Apunta para no repetirla nunca.