Inventario exhaustivo de la superficie SQL no soportada hoy. Sirve como roadmap concreto para cerrar el gap con un motor SQL relacional clásico. Cada feature lleva una prioridad (P0 = impacto crítico, P3 = nicho), un bloque sugerido (1 bloque = 1 push a main) y notas técnicas de implementación.

Última verificación: 2026-05-29 contra main post-Fase 3 P3. Stack acumulado de bloques cerrados desde la última auditoría del documento (~K2): G/H/I (subqueries+set-ops+derived), J (multi-row INSERT+UPSERT+RETURNING+TRUNCATE), K1/K2 (CTAS+composite PK), V (VIEW), W1/W2/W3 (CTEs+RECURSIVE+window functions), X1→X4f+X6 (triggers+procedures+functions+IF/CASE/WHILE/FOR/LOOP/DECLARE/RAISE/EXCEPTION/RETURN), Y1→Y9 (tipos extendidos+DECIMAL exacto+BLOB+UUID+UNSIGNED), Z1→Z3f (USERS+ROLES+PBKDF2/scrypt/Blake2b/Argon2id+GRANT/REVOKE+RLS), P1/P2/P3 (EXPLAIN+ANALYZE).

Cobertura SQL hoy: >85% de los comandos de un motor SQL clásico están implementados. Los huecos remanentes son específicos (savepoints, prepared statements, bind params, ARRAY/JSONB, cursores, planner real, COPY). Ver tabla “Resumen por prioridad” abajo y la sección “Próximas proyecciones” en ROADMAP.md.

📊 Gaps específicos identificados por el benchmark 2026-05-30: catálogo cerrado de 10 gaps en ADR-0066 — cada uno con código de error, query del bench que lo dispara, workaround y bloque/prioridad de fix definitivo. El más crítico: RANK() y SUM OVER cuadráticos (W4). Fuentes de verdad complementarias: SQL_REFERENCE.md (lo que SÍ se soporta), STATUS.md (madurez por subsistema), TECHNICAL_SPECS.md (formato + subset exacto).

🎯 Top 5 huecos por impacto práctico (refrescado 2026-05-29)

Histórico de huecos cerrados (movido al pie del archivo): E1, E2, E3, F, T, J, J2, G, H, I, K1, K2, L, V, W, X, Y, Z — todos los “P0 clásicos” del 2026-05-25..27 ya están entregados. La superficie SQL relacional clásica está cubierta. Los huecos remanentes son de rendimiento, herramientas y completitud avanzada, no de uso básico.

Si vas a ordenar bloques por ROI funcional hoy, este es el orden:

Estos 5 bloques son los que más mueven la aguja a partir de hoy. Los 3 primeros (P4+P5+T1) son los que el usuario sentido como “esta DB rinde” o “esta DB no rinde”.

📦 Plan de bloques sugerido (1 = 1 push)

Cada bloque deja main verde con tests + docs + nuevos códigos de error. Pensado para ejecutar de arriba hacia abajo, pero son razonablemente independientes salvo donde marca depende de.

🔴 1. Predicados y operadores en WHERE (Bloque E1 + E2)

1.1 Boolean combinators

✅ Cerrado en E1: el AST cambió a WhereExpr = And | Or | Not | Atom(WhereClause) con precedencia estándar (OR < AND < NOT < átomo) y lógica trivaluada para NULL. Limitación residual: EXISTS correlacionado y col = otra.col solo se aceptan como único átomo (combinarlos con AND/OR/NOT devuelve [GBY-4024]). Detalles en SQL_REFERENCE.md.

1.2 Comparadores

🔴 2. Agregaciones — el agujero más grande (Bloque F)

Plan de implementación (Bloque F): introducir Aggregate enum en el AST, nuevo executor stage post-WHERE/pre-ORDER que agrupa por las columnas del GROUP BY y calcula los agregados por bucket. Si no hay GROUP BY pero hay agregados, devuelve UNA sola fila (agregado global).

🔴 3. Funciones escalares (Bloque G)

Hoy sin ninguna función built-in. Lista mínima útil:

✅ Cerrado en G1 (2026-05-26) para SELECT list: parser + evaluator + 12 integration tests.

✅ Cerrado en G2 (2026-05-26) la extensión a WHERE / HAVING / UPDATE SET / DELETE WHERE / ON CONFLICT DO UPDATE SET: nuevo átomo WhereClause::ExprPredicate (FullScan + post-filter, sin perder los fast-paths estructurales) + assignments con RHS Expr evaluada contra la fila pre-update + helper eval_expr_as_predicate con 3VL. 20 integration tests adicionales. Limitaciones residuales para G3: operadores postfix sobre Expr (IS NULL/LIKE/IN/BETWEEN con LHS expresional → [GBY-4039]), operador ||, aritméticos binarios (+/-/*//), funciones P2/P3 (TRIM/REPLACE/CEIL/FLOOR/MOD/DATE_ADD/SUB/EXTRACT/…), y EXCLUDED.col en UPSERT.

String

| Función | Prioridad | |—|:—:| | LENGTH(s) | ✅ (G1, 2026-05-26) | | UPPER(s) / LOWER(s) | ✅ (G1, 2026-05-26) | | SUBSTR(s, from, len) / SUBSTRING | ✅ (G1, 2026-05-26) | | TRIM(s) / LTRIM / RTRIM | ✅ (G3, 2026-05-26) | | CONCAT(a, b, ...) | ✅ (G1, 2026-05-26) — operador \|\| ✅ (G3, 2026-05-26) | | REPLACE(s, from, to) | ✅ (G3, 2026-05-26) | | SPLIT_PART(s, sep, idx) | ✅ (G3, 2026-05-26) |

Numéricas

| Función | Prioridad | |—|:—:| | ABS(x) | ✅ (G1, 2026-05-26) | | ROUND(x, n) | ✅ (G1, 2026-05-26) | | CEIL(x) / FLOOR(x) | ✅ (G3, 2026-05-26) | | MOD(a, b) u operador % | ✅ (G3, 2026-05-26) | | POWER(x, y) / SQRT(x) | ✅ (G3, 2026-05-26) | | Operadores aritméticos +/-/*// | ✅ (G3, 2026-05-26) |

Fecha / hora

| Función | Prioridad | |—|:—:| | NOW() / CURRENT_TIMESTAMP | ✅ (G1, 2026-05-26) | | CURRENT_DATE | ✅ (G1, 2026-05-26) | | DATE_ADD(d, n_days) / DATE_SUB | ✅ (G3, 2026-05-26) | | DATEDIFF(d1, d2) | ✅ (G3, 2026-05-26) | | EXTRACT(YEAR FROM d) | ✅ (G3, 2026-05-26) | | STRFTIME(format, d) | ✅ (G3, 2026-05-26) |

Conversión y condicional

| Construcción | Prioridad | |—|:—:| | CAST(x AS TYPE) | ✅ (G1, 2026-05-26) | | COALESCE(a, b, ...) | ✅ (G1, 2026-05-26) | | NULLIF(a, b) | ✅ (G1, 2026-05-26) | | IFNULL(a, b) / IF(cond, a, b) | ✅ (G1, 2026-05-26; alias IIF aceptado) | | CASE WHEN ... THEN ... ELSE ... END | ✅ (G1, 2026-05-26) | | CASE col WHEN x THEN ... END (simple form) | ✅ (G1, 2026-05-26) |

🟡 4. Subqueries — variantes faltantes (Bloque H)

🟡 5. JOINs — variantes faltantes

Hoy soportadas: INNER, CROSS, LEFT/RIGHT/FULL [OUTER], USING (1 col), NATURAL (1 col común), multi-tabla chain, self-join, index-loop optimization. Faltan:

🟢 6. Set operations (Bloque I) — ✅ cerrado 2026-05-26

🔴 7. DML masivo y avanzado (Bloque E3 + J)

🔴 8. Transacciones explícitas (Bloque T)

Limitación documentada: ROLLBACK opera sobre el cache del Pager y descarta TODO lo cacheado en el batch, incluidas las sentencias previas al BEGIN. Funciona limpio cuando BEGIN es la primera sentencia del batch. Para abortar selectivo se necesita SAVEPOINT (P1).

🔴 9. DDL faltante (Bloque K + L)

Tabla y schema

| Comando | Soportado | Prioridad | |—|:—:|:—:| | CREATE TABLE con PRIMARY KEY(a,b) compuesta | ✅ (K2, 2026-05-26) | all-INT NOT NULL, ver ADR-0019 | | CREATE TABLE ... AS SELECT ... (CTAS) | ✅ (K1, 2026-05-26; primera col del SELECT debe ser INT no-NULL → PK) | — | | CREATE TEMPORARY TABLE | ❌ | P2 | | ALTER TABLE ADD COLUMN | ✅ | — | | ALTER TABLE DROP COLUMN | ✅ (K1, 2026-05-26; con IF EXISTS; bloqueado sobre PK / indexada / FK) | — | | ALTER TABLE RENAME COLUMN | ✅ (K1, 2026-05-26; arrastra PK + índices + FKs entrantes) | — | | ALTER TABLE RENAME TO | ✅ (K1, 2026-05-26; alias RENAME TABLE; arrastra FKs entrantes) | — | | ALTER TABLE ADD [CONSTRAINT name] CHECK (expr) | ✅ (L3, 2026-05-27; re-valida filas existentes con full-scan, aborta con [GBY-3008] sin estado parcial) | — | | CREATE TABLE (..., CONSTRAINT name PRIMARY KEY/UNIQUE/FOREIGN KEY ...) | ✅ (residual #2, 2026-05-27; FK single-col únicamente) | — | | ALTER TABLE ADD CONSTRAINT name PRIMARY KEY/UNIQUE/FOREIGN KEY | ❌ | P2 | | ALTER TABLE DROP CONSTRAINT [IF EXISTS] <name> | ✅ (residual #2, 2026-05-27; lookup CHECK/UNIQUE/FK; PK rechazada con [GBY-4072]) | — | | ALTER TABLE ALTER COLUMN ... TYPE ... | ❌ | P2 (K2 — requiere rewrite tipado) | | DROP TABLE ... CASCADE | ❌ | P2 |

Índices

| Comando | Soportado | Prioridad | |—|:—:|:—:| | CREATE INDEX ... ON t (col) single | ✅ | — | | CREATE UNIQUE INDEX | ✅ | — | | CREATE INDEX ... ON t (a, b, ...) compuesto | ✅ (K2, 2026-05-26) | all-INT, equality-only via fingerprint FNV-1a-64 | | CREATE INDEX ... ON t (col) WHERE cond (partial) | ❌ | P2 | | CREATE INDEX ... INCLUDE (...) (covering) | ❌ | P3 | | REINDEX | ❌ | P3 |

Constraints

| Constraint | Soportado | Prioridad | |—|:—:|:—:| | PRIMARY KEY (single INT) | ✅ | — | | NOT NULL | ✅ | — | | UNIQUE (inline + standalone) | ✅ | — | | DEFAULT <literal> | ✅ | — | | FOREIGN KEY ... ON DELETE RESTRICT|CASCADE | ✅ | — | | FOREIGN KEY ... ON DELETE SET NULL | ✅ (L1, 2026-05-27; [GBY-3009] si la columna del child es NOT NULL) | — | | FOREIGN KEY ... ON DELETE SET DEFAULT | ✅ (L1, 2026-05-27; [GBY-3010] si no hay DEFAULT) | — | | FOREIGN KEY ... ON DELETE NO ACTION | ✅ (L1, 2026-05-27; alias de RESTRICT en este release) | — | | FOREIGN KEY ... ON UPDATE ... | ✅ activación real (residual #4, 2026-05-27): UPDATE de PK lifted; CASCADE/SET NULL/SET DEFAULT/RESTRICT/NO ACTION disparados sobre cada FK entrante. UPSERT DO UPDATE sigue restringido | — | | FOREIGN KEY (a, b) REFERENCES p (x, y) multi-col | ✅ (residual #3, 2026-05-27; target = PK compuesta del parent vía fingerprint K2) | — | | CHECK (cond) | ✅ (L2, 2026-05-27) — column-level + table-level, con/sin nombre, 3VL ANSI, sin subqueries ([GBY-4069]) | — | | EXCLUDE USING ... (Postgres-style) | ❌ | P3 | | Constraints diferidas (DEFERRABLE INITIALLY DEFERRED) | ❌ | P3 | | Multi-column PRIMARY KEY standalone | ✅ (K2, 2026-05-26; all-INT NOT NULL) | — | | Multi-column UNIQUE standalone table-level | ✅ (L1, 2026-05-27; all-INT NOT NULL, mismo encoder que K2) | — |

🔴 10. Vistas, sequences, triggers (Bloques V + X)

🔴 11. CTE y window functions (Bloque W)

🟡 12. Tipos faltantes (Bloque Y)

🔴 13. Control de acceso (Bloque Z)

Hoy: solo token compartido en el server HTTP. Nada de SQL-level.

🟡 14. Otros del estándar

🧮 Resumen por prioridad

🛣️ Ruta recomendada para “línea de comandos completa”

Si el objetivo es portar una app SQL clásica sin sorpresas, esta es la secuencia mínima (todos cerrados hoy):

E1 (AND/OR/NOT en WHERE)                                ✅
  ↓
E2 (operadores <, >, LIKE, IS NULL, IN literal)         ✅
  ↓
E3 (UPDATE/DELETE por col indexada y subquery)          ✅
  ↓
F (GROUP BY + HAVING + agregados + DISTINCT)            ✅ (sin JOINs)
  ↓
T (BEGIN / COMMIT / ROLLBACK explícitos)                ✅ (batch-local)
  ↓
J (multi-row INSERT, INSERT...SELECT, TRUNCATE)         ✅
  ↓
J2 (UPSERT, REPLACE INTO, RETURNING)                    ✅ (sin EXCLUDED.col)
  ↓
G1+G2+G3 (funciones escalares + CAST + CASE +
          COALESCE + aritméticos + || + postfix Expr)   ✅
  ↓
H (derived tables, NOT IN (SELECT), subquery en SELECT,
   correlated multi-pred)                               ✅
  ↓
I (UNION, INTERSECT, EXCEPT, MINUS, VALUES)             ✅
  ↓
K1 (CTAS, RENAME TABLE, DROP/RENAME COLUMN)             ✅
  ↓
K2 (PK compuesta + índices compuestos all-INT)          ✅ (VERSION 8)
  ↓
L (CHECK, ON DELETE SET NULL, multi-col UNIQUE)         ⏳

Con E1→K2 cerrados, gabysql cubre la superficie SQL operacional clásica completa. Lo que sigue (L = constraints adicionales, V = vistas, W = CTE + window, X = triggers + stored procs, Y = tipos exóticos DECIMAL/BLOB/UUID, Z = RLS) es material para casos especializados.

📚 Referencias cruzadas

• SQL_REFERENCE.md — gramática EBNF + railroad de TODO lo que SÍ se soporta.
• STATUS.md — madurez por subsistema con la línea de demarcación 🟢/🟡/🔴.
• ERROR_CODES.md — catálogo [GBY-NNNN] (nuevos códigos se agregan acá al cerrar cada bloque).
• TECHNICAL_SPECS.md — formato en disco + subset SQL exacto.
• ROADMAP.md — dirección técnica general (no entra en este detalle de comandos).
• AGENDA_INVESTIGACION.md — qué entra y qué no en términos de aprendizaje (algunos bloques de acá pueden ser “anti-agenda” según el momento).