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 lectura3 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.
SQLite es una base de datos que vive en un solo fichero. En Go la abres con database/sql y el driver modernc.org/sqlite, igual que en PHP haces new PDO("sqlite:tareas.db").
SQLite no tiene BOOLEAN ni DATETIME: hecha se guarda como 0/1 y la fecha como texto. Al leer una fila hay que traducirla a la Tarea de Go, como harías con (bool) $fila['hecha'] en PHP.
Las migraciones son ficheros .sql numerados que se aplican en orden y una sola vez, como las de Laravel o Phinx. Con //go:embed viajan dentro del binario.
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).
Fase 1: el esquema en SQLite y las migraciones (esta lección).
Fase 2: el dominio, la entidad Tarea y sus reglas.
Fase 3: el repositorio, una interfaz con dos versiones: SQLite y en memoria.
Fase 4: los casos de uso: crear, listar, completar y borrar.
Fase 5: controladores y vistas con net/http y html/template.
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
Go
Qué va dentro
En un PHP con DDD
cmd/tareas/main.go
Abre la BD, cablea las piezas y arranca el servidor
public/index.php + el contenedor de dependencias
internal/dominio
La entidad Tarea, sus reglas y sus errores
src/Domain
internal/repositorio
Cómo se guardan las tareas (SQL)
src/Infrastructure/Repository
internal/casosdeuso
Lo que la app sabe hacer, un caso por acción
src/Application (los services o handlers)
internal/web
Rutas, controladores y vistas
src/Infrastructure/Http + templates/
go.mod
Nombre del módulo y dependencias
composer.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).
PHP
Go
Quién lo ve
namespace App\Domain;
package dominio
El nombre corto con el que lo llaman los demás
use App\Domain\Tarea;
import "tareas/internal/dominio" y luego dominio.Tarea
Cualquier 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 Composer
La ruta de la carpeta es el nombre del import
No 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í.
Columna
Tipo en SQLite
Tipo en Go al leer
En la Tarea
id
INTEGER
int64
ID int
titulo
TEXT
string
Titulo string
prioridad
INTEGER (0, 1, 2)
int64
Prioridad Prioridad (el enum del módulo 04)
hecha
INTEGER (0 o 1)
int64
Hecha bool
creada_en
TEXT
string
No 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 {
IDint64TitulostringPrioridadint64Hechaint64
}
funcmain() {
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
<?phpdeclare(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 ($ficherosas$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/*.sqlvar migracionesFS embed.FS// Migrar aplica, en orden, las migraciones que falten.funcMigrar(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)
}
}
returnnil
}
funcaplicar(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"
)
funcmain() {
// 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.funcAbrir(ruta string) (*sql.DB, error) {
db, err := sql.Open("sqlite", ruta)
if err != nil {
returnnil, 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()
returnnil, 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
funcTestMigrarDosVeces(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.forrange2 {
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:
golang-migrate: migraciones up/down con un comando, muy usado.
sqlc: escribes el SQL y te genera el código Go con tipos. Lo más parecido a no escribir Scan a mano.
Hora de practicar
Retos · 0/3 resueltos
Reto 1 de 3 · ✓ Resuelto
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
Pista. Go no convierte un número en bool: compara (n == 1). Para el camino de vuelta, un if b { return 1 } y si no, 0.
Reto 2 de 3 · ✓ Resuelto
Las migraciones que faltan
Completa Pendientes(todas []string, aplicadas map[string]bool) []string: devuelve los nombres de todas que no estén en aplicadas, ordenados alfabéticamente. Por ejemplo, con todas = ["002_etiquetas.sql", "001_crear_tareas.sql", "003_indices.sql"] y 001 aplicada, devuelve ["002_etiquetas.sql", "003_indices.sql"]. Es el array_filter() + sort() de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Recorre todas y quédate con las que den false en aplicadas[nombre] (una clave que no existe da el valor cero, false). Ordena el nuevo slice con slices.Sort: si ordenas todas, cambias el slice de quien te llama.
Reto 3 de 3 · ✓ Resuelto
De fila a Tarea
Completa FilaATarea(f Fila) (Tarea, error): copia ID y Titulo, convierte Prioridad (0-2, si no, error), convierte Hecha (0 o 1, si no, error) y parte Etiquetas por comas ("casa,urgente" → ["casa", "urgente"]; un texto vacío → ninguna etiqueta). Es lo que harías en PHP en un fromRow(array $fila).
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Igual que explode(",", "") en PHP, strings.Split("", ",") no devuelve una lista vacía sino [""]: una etiqueta vacía. Mira primero si el texto está vacío. Y valida Hecha y Prioridad antes de construir la tarea.
Resumen
Lo que te llevas de esta lección
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).
internal/ lo protege el compilador (en PHP, @internal es solo un aviso).
database/sql + modernc.org/sqlite es tu PDO + pdo_sqlite, sin cgo y sin compilador de C.
SQLite guarda hecha como 0/1: se traduce con f.Hecha == 1 (en PHP, (bool) $fila['hecha']).
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.