DBA · Catálogo de datos
El catálogo de datos que no se pudre
2026-06-12 · 6 min · Español
Todo el que ha trabajado con datos empresariales conoce el ciclo: alguien arma un diccionario de datos
en Excel o en un wiki, se celebra, y seis meses después nadie lo ha actualizado. La columna nueva no está,
la tabla renombrada sigue con el nombre viejo, y los analistas vuelven a lo de siempre —
adivinar qué significa cada columna por el nombre. Con la IA el problema se multiplica:
un agente que adivina mal no duda, ejecuta.
Un catálogo es infraestructura, no documentación. Si no se regenera solo y no se
verifica contra la fuente, ya nació muerto.
Lo que construimos en cambio
Para nuestro despliegue en producción construimos tres piezas, todas dentro de la base de datos,
no al lado de ella:
- El diccionario oficial — una tabla curada de descripciones unida en vivo al inventario
real de Postgres (
pg_catalog). Si una columna existe, aparece; si no está documentada, el sistema
lo dice honestamente (documented = false) en vez de inventar. Hoy: ~4,500 entradas curadas
sobre 600+ tablas y vistas.
- La capa semántica de joins — cómo se unen las tablas, con las columnas exactas,
la cardinalidad y las trampas. Incluye relaciones NON-JOIN: pares de columnas que parecen unibles
y NO lo son, documentadas para que nadie (humano o agente) caiga dos veces.
- El mapa interactivo — un HTML autocontenido generado desde la base: busca una tabla,
ve su descripción, su llave primaria y cada relación con un clic. Regenerarlo es un comando.
La parte que casi nadie hace: verificar contra la fuente
Describir una columna por su nombre es fácil y peligroso. Nuestro estándar es otro: extrajimos el SQL
original del ERP del cliente (más de 1,500 consultas de sus formularios y reportes) y reconciliamos
tres vías: lo que dice el ERP, lo que hay en el espejo de datos, y lo que calculan
nuestras vistas — hasta el centavo. Las descripciones que pasaron por esa auditoría llevan un sello
(verificado ✓) distinto de las descripciones razonables-pero-no-auditadas.
Ese proceso encontró joyas que ningún diccionario por nombre habría capturado:
- Una columna llamada
cantidad_regalia que no registra regalías — es un contador de despacho.
- Un tipo de documento que guarda el costo por unidad cuando todos los demás lo guardan por empaque
— un error de agregación de 77× esperando a quien no lo supiera.
- Números de factura que se repiten entre tipos de documento: todo join que no incluya el tipo está
silenciosamente mal.
Agents-first: el catálogo como herramienta de la IA
Aquí está el giro que lo cambia todo: el primer consumidor del catálogo no es una persona — son los
agentes de IA. Antes de escribir SQL, nuestros agentes consultan el diccionario (¿qué significa esta
columna?) y la capa de joins (¿cómo se une esto, y por dónde NO?):
$ apexia-pg-joins tfat_factura tinv_producto
2 saltos: factura → kardex (tipo_factura,no_factura) → producto
⚠ la clave INCLUYE tipo_factura — no_factura se repite entre FT/AN/FC
Y cuando un agente descubre un join que no estaba documentado, lo verifica contra la fuente y lo
inserta de vuelta en la capa. El catálogo se enriquece con el uso. Por eso no se pudre:
no depende de la buena voluntad de nadie — es el camino de menor resistencia para hacer el trabajo.
Los catálogos mueren cuando mantenerlos es trabajo extra. El nuestro vive porque
usarlo y mantenerlo son la misma acción.
Esto también es un servicio
Lo que describimos arriba es exactamente lo que las plataformas de catálogo empresarial venden por
decenas de miles de dólares al año — con una diferencia: lo nuestro corre dentro de tu Postgres,
se regenera solo, se verifica contra tu ERP real, y no le paga renta a nadie. Si tu empresa tiene un ERP
con años de historia y nadie sabe ya qué significa la mitad de las columnas, ese es precisamente el
problema que sabemos resolver.
¿Tu ERP guarda secretos que ya nadie recuerda?
Hablemos de construir tu capa semántica verificada — diccionario, joins y mapa incluidos.
Solicitar demo
DBA · Data Catalog
The Data Catalog That Doesn't Rot
2026-06-12 · 6 min · English
Everyone who has worked with enterprise data knows the cycle: someone builds a data dictionary
in Excel or a wiki, it gets celebrated, and six months later nobody has updated it. The new column isn't there,
the renamed table still goes by its old name, and the analysts go back to business as usual —
guessing what each column means from its name. With AI the problem multiplies:
an agent that guesses wrong doesn't hesitate, it executes.
A catalog is infrastructure, not documentation. If it doesn't regenerate itself and isn't
verified against the source, it was born dead.
What we built instead
For our production deployment we built three pieces, all of them inside the database,
not next to it:
- The official dictionary — a curated table of descriptions joined live against Postgres's
real inventory (
pg_catalog). If a column exists, it shows up; if it isn't documented, the system
says so honestly (documented = false) instead of making something up. Today: ~4,500 curated entries
across 600+ tables and views.
- The join semantic layer — how the tables join, with the exact columns,
the cardinality, and the traps. It includes NON-JOIN relationships: pairs of columns that look joinable
and are NOT, documented so that nobody (human or agent) falls for it twice.
- The interactive map — a self-contained HTML generated from the database: search for a table,
see its description, its primary key, and every relationship with one click. Regenerating it is one command.
The part almost nobody does: verifying against the source
Describing a column by its name is easy and dangerous. Our standard is different: we extracted the original SQL
from the client's ERP (more than 1,500 queries from its forms and reports) and reconciled
three ways: what the ERP says, what's in the data mirror, and what our views
compute — down to the cent. Descriptions that passed that audit carry a stamp
(verificado ✓, "verified") distinct from the reasonable-but-unaudited descriptions.
That process found gems no name-based dictionary would ever have captured:
- A column named
cantidad_regalia that doesn't record giveaway goods ("regalías") — it's a dispatch counter.
- A document type that stores cost per unit when every other one stores it per package
— a 77× aggregation error waiting for whoever didn't know.
- Invoice numbers that repeat across document types: any join that doesn't include the type is
silently wrong.
Agents-first: the catalog as a tool for the AI
Here's the twist that changes everything: the catalog's first consumer isn't a person — it's the
AI agents. Before writing SQL, our agents query the dictionary (what does this
column mean?) and the join layer (how does this join, and where does it NOT?):
$ apexia-pg-joins tfat_factura tinv_producto
2 saltos: factura → kardex (tipo_factura,no_factura) → producto
⚠ la clave INCLUYE tipo_factura — no_factura se repite entre FT/AN/FC
And when an agent discovers a join that wasn't documented, it verifies it against the source and
inserts it back into the layer. The catalog gets richer with use. That's why it doesn't rot:
it doesn't depend on anyone's goodwill — it's the path of least resistance for getting the work done.
Catalogs die when maintaining them is extra work. Ours lives because
using it and maintaining it are the same action.
This is also a service
What we describe above is exactly what enterprise catalog platforms sell for
tens of thousands of dollars a year — with one difference: ours runs inside your Postgres,
regenerates itself, is verified against your real ERP, and pays rent to no one. If your company has an ERP
with years of history and nobody knows anymore what half the columns mean, that is precisely the
problem we know how to solve.
Does your ERP hold secrets nobody remembers anymore?
Let's talk about building your verified semantic layer — dictionary, joins, and map included.
Request a demo