{"canonical_url":"https://engineer.company/es/glossary/orm/","content_markdown":"# ORM\n\n## Qué es\n\nUn ORM, abreviatura de object-relational mapper, o mapeador objeto-relacional,\nes una biblioteca que asigna las tablas de una base de datos relacional a clases\ndel código de aplicación y sus filas a objetos. El código pide un autor y recibe\nun objeto `Author`, cambia uno de sus atributos y lo guarda, y el ORM escribe las\nsentencias `SELECT`, `INSERT` y `UPDATE` que realizan el trabajo. Los modelos de Django y el\nORM de SQLAlchemy, ambos escritos en Python, son dos ejemplos conocidos y los\ndos en los que se apoya este artículo.\n\nEsa correspondencia es necesaria porque ambos lados organizan los datos de forma\ndistinta. Martin Fowler lo explica claramente en su descripción del patrón Data\nMapper: los objetos y las bases de datos relacionales tienen formas diferentes\nde estructurar datos, y algunas partes de un modelo de objetos, como las\ncolecciones y la herencia, no tienen equivalente en una base de datos\nrelacional. Mover datos entre ambos se convierte en un problema propio, y un ORM\nofrece una solución lista para utilizar.\n\nLas partes de esa respuesta recibieron sus nombres en el libro de Fowler\nPatterns of Enterprise Application Architecture, publicado en 2003, cuyo\ncatálogo de patrones está disponible en línea. Dos patrones describen la forma\ngeneral. Active Record es un objeto que envuelve una fila de una tabla, gestiona\nsu propio acceso a la base de datos y contiene la lógica de dominio de esos\ndatos; la filosofía de diseño de Django dice que sus modelos siguen ese patrón.\nData Mapper es una capa separada que mueve datos entre los objetos y la base de\ndatos manteniéndolos independientes, de modo que los objetos no necesitan saber\nque existe una base de datos. Alrededor de ellos hay patrones menores. Identity\nMap se asegura de que cada objeto se cargue una sola vez. Unit of Work mantiene\nuna lista de los objetos que ha cambiado una tarea y escribe los cambios juntos.\nLazy Load es un objeto que solo contiene parte de los datos que necesita el\ncódigo, pero sabe obtener el resto. La documentación de SQLAlchemy nombra\ndirectamente dos de ellos: su `Session` mantiene los objetos cargados en un mapa de\nidentidad, con un solo objeto por clave primaria, y su forma de reunir cambios y\nvolcarlos a la base de datos es el patrón de unidad de trabajo.\n\n## Por qué importa\n\nLa primera razón es la cantidad de código que ahorra. En su ensayo ORM Hate de\n2012, Fowler considera difícil el problema del mapeo objeto-relacional: implica\nmantener sincronizadas dos representaciones muy distintas de los mismos datos, y\ncualquier cambio en un lado debe trasladarse al otro. Su estimación es que un\nORM resuelve aproximadamente entre el 80 y el 90 % de los problemas de mapeo, y\nsostiene que un marco que ahorre a un equipo el 80 % de ese trabajo merece la\npena aunque no vaya más allá. Cada tabla que un equipo no mapea a mano es un\nlugar menos donde leer una columna en el atributo equivocado.\n\nLa segunda razón es la coherencia dentro de un programa en ejecución. Con un\nmapa de identidad, dos consultas que encuentran la misma fila devuelven el mismo\nobjeto, así que un cambio mediante una referencia resulta visible mediante la\notra; la documentación de SQLAlchemy lo demuestra cargando dos veces la misma\nclave primaria y obteniendo el mismo objeto. Con una unidad de trabajo, el ORM\nreúne las inserciones, actualizaciones y eliminaciones pendientes y, en palabras\nde la lista de características de SQLAlchemy, las vuelca todas en un lote, de\nmodo que el código de aplicación no tenga que recordar qué objetos tocó. Django\nelige deliberadamente lo contrario: su filosofía de diseño exige un `save()`\nexplícito en vez de guardar de forma implícita, para que el marco envíe el menor\nnúmero posible de sentencias SQL.\n\nLa tercera razón es dónde se sitúa el límite. Fowler describe un buen ORM como\naquel que se encarga del trabajo rutinario y «ofrece pozos de acceso para poder\nbajar a trabajar con SQL» cuando hace falta, y afirma sin rodeos que cualquiera\nque construya una aplicación sobre una base de datos relacional debería saber\ncómo funciona una. La filosofía de diseño de Django dice lo mismo desde el lado\ndel marco: la API de base de datos debe concebirse como un atajo y no como la respuesta\ncompleta, y debe facilitar escribir SQL propio, ya sea una sentencia entera o\nuna sola cláusula `WHERE`. Un ORM se gana su lugar en los accesos rutinarios, que constituyen la mayoría; el resto es donde un equipo emplea sus conocimientos de SQL.\n\n## Cómo se aplica en la práctica\n\nEl coste que más suele ocultar un ORM es el número de consultas que envía. En\nSQLAlchemy 2.1, la carga diferida de las relaciones es la opción predeterminada: los\nobjetos relacionados se obtienen la primera vez que el código accede al\natributo. La documentación explica la consecuencia: para N objetos cargados,\nacceder a sus atributos de carga diferida implica N+1 sentencias `SELECT`. El ejemplo\nsiguiente supone clases `Author` y `Book` ya mapeadas, con una relación uno a muchos\n`Author.books`, y recorre los autores de tres maneras.\n\n```python\nfrom sqlalchemy import select\nfrom sqlalchemy.orm import raiseload, selectinload\n\n# The default: one SELECT for the authors, then one more for each\n# author whose books the loop touches, N+1 statements in all.\nauthors = session.scalars(select(Author)).all()\nfor author in authors:\n    print(author.name, len(author.books))\n\n# select IN loading: a second SELECT fetches the books of every\n# author at once, with the authors' primary keys in an IN clause.\nstmt = select(Author).options(selectinload(Author.books))\nfor author in session.scalars(stmt).all():\n    print(author.name, len(author.books))\n\n# raise loading: touching author.books now raises an error\n# instead of quietly sending another query.\nstmt = select(Author).options(raiseload(Author.books))\n```\n\nPara colecciones uno a muchos y muchos a muchos, la documentación considera `selectinload()`\ngeneralmente la mejor estrategia. `joinedload()`, que denomina la estrategia de uso más\ngeneral, añade un `JOIN` a la sentencia original, un `LEFT OUTER JOIN` con la configuración predeterminada, de modo que\nlas filas relacionadas llegan en el mismo conjunto de resultados. `raiseload()` existe\npara impedir cargas no deseadas, y su forma con comodín, `raiseload(\"*\")`, extiende la\nprotección también a las demás relaciones, incluidas las de los objetos que la\nsentencia sí carga.\n\nDjango 6.1 da a la misma elección un nombre propio: modos de obtención. Cuando\nel código accede a un campo que no cargó la consulta original, como una clave\nforánea, una relación uno a uno o un campo omitido con `defer()` u `only()`, el modo\npredeterminado, `FETCH_ONE`, lo obtiene para esa única instancia, y la propia\ndocumentación llama al resultado el problema de las consultas N+1. `FETCH_PEERS`, nuevo en\nla versión 6.1, obtiene el campo que falta para esa instancia y todas las demás\ndel mismo `QuerySet`, con el razonamiento de que un código que necesita un campo de una\nfila suele necesitarlo en todas. `FETCH_RAISE` lanza `FieldFetchBlocked` en su lugar. Se establece un modo\npor `QuerySet`, como en `Book.objects.fetch_mode(models.FETCH_PEERS)`, o como valor predeterminado de un modelo mediante un\ngestor personalizado, y Django lo copia a los objetos relacionados que obtiene.\nCuando `FETCH_PEERS` no es apropiado o suficientemente eficiente, la guía de optimización\nremite a `select_related()` y `prefetch_related()`.\n\nLas propias páginas de la empresa sitúan el límite más cerca de la base de datos\nque la mayoría. Su [pila tecnológica](/es/tech-stack/) trata SQL como un lenguaje de primera clase, en vez de\ncomo algo que genera un ORM, porque ahí se concentra la mayor parte del trabajo\nde rendimiento para el que se recurre a la empresa. En su trabajo bajo\nNextMariner, la fundadora llevó ese enfoque hasta sus últimas consecuencias con\n[una capa de datos PostgreSQL centrada en funciones](/es/portfolio/designed-a-function-first-postgresql-data-layer/): cada operación que puede hacer la aplicación es una de 1.275 funciones\nalmacenadas repartidas entre 34 esquemas, y no hay ningún acceso directo a\ntablas desde Go. El rol con el que inicia sesión la API tiene `EXECUTE` sobre esas\nfunciones y `USAGE` sobre sus esquemas y nada más, por lo que no puede tocar una\ntabla directamente. La página es clara sobre el precio: un campo nuevo significa\ncambiar tanto una tabla como una función, no añadir una línea a una consulta.\n\n## Dónde surgen los problemas\n\n**Un bucle envía una consulta por fila.** El patrón N+1 anterior parece\ninofensivo en una pequeña base de datos de desarrollo y hace que la página se\nvuelva más lenta a medida que aumenta el número de filas. Decida la carga para\ncada ruta importante, con `selectinload()` o `joinedload()` en SQLAlchemy y `FETCH_PEERS`, `select_related()` o `prefetch_related()` en Django.\nDespués haga que el caso imprevisto falle de forma visible: `raiseload()` en SQLAlchemy o\n`FETCH_RAISE`, que la documentación de Django presenta como una forma de impedir consultas\ninvoluntarias en código donde el rendimiento es crítico.\n\n**Nadie lee el SQL que escribe el ORM.** Un ORM escribe SQL que nadie del equipo\neligió, y ese SQL permanece invisible hasta que una página se vuelve lenta. La\nguía de optimización de Django empieza aquí: averigüe qué consultas ejecuta una\npágina y cuánto cuestan, utilice `QuerySet.explain()` para ver cómo ejecuta la base de datos un\n`QuerySet` concreto y lea `django.db.connection.queries` para ver lo que escribe Django en nombre del código.\nIncluya la lectura de ese SQL en la revisión de cada página o tarea importante y\nanalice las sentencias lentas mediante el plan de ejecución de la propia base de\ndatos.\n\n**El trabajo que corresponde a la base de datos se ejecuta en Python.** Cargar\nfilas solo para filtrarlas, comparar dos de sus campos o sumarlas lleva cada\nfila por la conexión para hacer en el código de aplicación lo que la base de\ndatos podría hacer donde ya están los datos. La guía de Django enumera las\nalternativas: `filter()` y `exclude()` para filtrar en la base de datos, expresiones `F()` para\ncomparar campos del mismo modelo y `annotate()` para agregar en la base de datos. Las\nescrituras siguen la misma regla, con `bulk_create()` y `bulk_update()` en vez de un `save()` por objeto,\ndespués de comprobar las salvedades que la documentación enumera para ambos.\nPara un conjunto de resultados muy grande, un `QuerySet` conserva todo lo que ha leído\ny puede consumir mucha memoria, e `iterator()` puede ayudar.\n\n**La última parte se fuerza a pasar por el ORM.** La propia estimación de Fowler\ndeja entre el 10 y el 20 % de los problemas de mapeo, y esa última parte, en sus\npalabras, siempre requiere un trabajo cuidadoso. Doblegar el ORM hasta que\nproduzca una sentencia concreta oculta ese trabajo dentro de SQL generado que\nnadie eligió. Escriba esas sentencias en SQL y revíselas como cualquier otro\ncódigo. La guía de Django nombra los pasos para bajar de nivel: la expresión `RawSQL`\nañade SQL explícito a una consulta, menos portable pero más potente, y, más\nallá, un equipo puede escribir su propio SQL para recuperar datos o rellenar\nmodelos. Mantenga el ORM para los registros rutinarios, donde más ahorra y menos\ncuesta.\n\n## Lecturas adicionales\n\n- [Catálogo de patrones de arquitectura de aplicaciones empresariales](https://martinfowler.com/eaaCatalog/)\n  — resúmenes de Martin Fowler sobre Active Record, Data Mapper, Unit of Work,\n  Identity Map y Lazy Load.\n- [Odio al ORM](https://martinfowler.com/bliki/OrmHate.html)\n  — por qué el problema del mapeo objeto-relacional es difícil y cuánto puede\n  asumir un marco.\n- [Técnicas de carga de relaciones](https://docs.sqlalchemy.org/en/21/orm/queryguide/relationships.html)\n  — carga diferida, select IN, por combinación y con lanzamiento de errores en SQLAlchemy 2.1, y\n  cuál elegir.\n- [Modos de obtención](https://docs.djangoproject.com/en/stable/topics/db/fetch-modes/)\n  — `FETCH_ONE`, `FETCH_PEERS` y `FETCH_RAISE`, nuevos en Django 6.1.\n- [Optimización del acceso a bases de datos](https://docs.djangoproject.com/en/stable/topics/db/optimization/)\n  — análisis de rendimiento, evaluación de `QuerySet`, trabajo dentro de la base de\n  datos, métodos masivos y SQL directo.\n\n\u003chttps://engineer.company/es/glossary/orm/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Qué hace un ORM entre objetos y tablas, qué patrones de Fowler lo componen, cuánto cuesta cargar filas relacionadas y cuatro formas de utilizarlo mal.","formats":{"gemtext":"https://engineer.company/es/glossary/orm/index.gmi","gopher":"https://engineer.company/es/glossary/orm/gophermap","html":"https://engineer.company/es/glossary/orm/","json":"https://engineer.company/es/glossary/orm/index.json","markdown":"https://engineer.company/es/glossary/orm/index.md","pdf":"https://engineer.company/es/glossary/orm/index.pdf"},"kind":"page","language":"es","title":"¿Qué es un ORM?","url":"https://engineer.company/es/glossary/orm/","version":1}