{"canonical_url":"https://engineer.company/uk/glossary/orm/","content_markdown":"# ORM\n\n## Що це таке\n\nORM, скорочення від object-relational mapper, — це бібліотека, яка пов'язує\nтаблиці реляційної бази даних із класами в коді застосунку, а рядки цих таблиць\n— з об'єктами. Код просить автора й отримує об'єкт `Author`, змінює один з його\nатрибутів і зберігає його, а ORM пише інструкції `SELECT`, `INSERT` і `UPDATE`,\nякі виконують цю роботу. Моделі Django та ORM-частина SQLAlchemy, обидві\nнаписані на Python, — два відомі приклади, і саме на них спирається ця стаття.\n\nВідображення потрібне тому, що дві сторони організовують дані по-різному. Мартін\nФаулер прямо каже про це в описі патерну Data Mapper: об'єкти й реляційні бази\nданих структурують дані кожен по-своєму, а частини об'єктної моделі, як-от\nколекції та успадкування, не мають відповідника в реляційній базі. Перенесення\nданих між ними стає окремою задачею, і ORM — готова відповідь на неї.\n\nСкладники цієї відповіді отримали назви в книзі Фаулера Patterns of Enterprise\nApplication Architecture 2003 року, а каталог патернів із неї вільно доступний\nонлайн. Два патерни описують загальну форму. Active Record — це об'єкт, який\nобгортає один рядок таблиці, сам відповідає за доступ до бази й несе доменну\nлогіку для цих даних; за філософією дизайну Django, моделі там наслідують саме\nцей патерн. Data Mapper — окремий шар, який переносить дані між об'єктами та\nбазою і тримає їх незалежними одне від одного, тож об'єктам навіть не треба\nзнати, що база взагалі існує. Навколо них є кілька менших патернів. Identity Map\nстежить, щоб кожен об'єкт завантажувався лише один раз. Unit of Work веде список\nоб'єктів, які змінила певна частина роботи, і записує зміни разом. Lazy Load —\nце об'єкт, що містить лише частину даних, потрібних коду, але знає, як отримати\nрешту. Документація SQLAlchemy прямо називає два з них: `Session` тримає\nзавантажені об'єкти в identity map, де на кожен первинний ключ припадає лише\nодин об'єкт, а спосіб, яким вона збирає зміни та скидає їх у базу через flush, —\nце патерн unit of work.\n\n## Чому це важливо\n\nПерша причина — скільки коду ORM заощаджує. У есеї ORM Hate 2012 року Фаулер\nназиває задачу об'єктно-реляційного відображення складною: йдеться про те, щоб\nтримати синхронними два дуже різні представлення тих самих даних, і зміну з\nодного боку треба перенести на інший. За його оцінкою, ORM розв'язує приблизно\nвід 80 до 90% задач відображення, і він вважає, що фреймворк, який позбавляє\nкоманду 80% цієї роботи, вартий того, навіть якщо на цьому він і зупиняється.\nКожна таблиця, яку команді не доводиться відображати вручну, — це на одне місце\nменше, де стовпець може потрапити не в той атрибут.\n\nДруга причина — узгодженість усередині запущеної програми. З identity map два\nзапити, які знаходять той самий рядок, повертають той самий об'єкт, тож зміна,\nзроблена через одне посилання, видна через інше; документація SQLAlchemy показує\nце, двічі завантажуючи той самий первинний ключ і отримуючи той самий об'єкт. З\nunit of work ORM збирає вставлення, оновлення й видалення, що очікують, і, за\nсписком можливостей SQLAlchemy, скидає їх у базу одним пакетом, тож коду\nзастосунку не треба самому пам'ятати, яких об'єктів він торкався. Django свідомо\nробить протилежний вибір: його філософія дизайну вимагає явного виклику `save()`\nзамість того, щоб фреймворк зберігав дані непомітно, і так надсилає якомога\nменше SQL-інструкцій.\n\nТретя причина — те, де проходить межа. Фаулер описує добру ORM як таку, що бере\nна себе рутину, але залишає люк, через який можна спуститися до SQL, коли це\nпотрібно, і прямо каже, що кожен, хто будує на реляційній базі даних, мусить\nзнати, як така база працює. Філософія дизайну Django каже те саме з боку\nфреймворку: API для роботи з базою має розуміти, що воно лише скорочений шлях, а\nне обов'язково вся відповідь, і фреймворк має робити власний SQL простим у\nнаписанні — чи то цілі інструкції, чи лише власна умова `WHERE`. ORM заслуговує\nна своє місце в рутинній частині доступу до даних; решта — те, на що команда\nвитрачає своє знання SQL.\n\n## Як це виглядає на практиці\n\nЦіна, яку ORM приховує найчастіше, — кількість запитів, які вона надсилає. У\nSQLAlchemy 2.1 зв'язки за замовчуванням завантажуються ліниво: пов'язані об'єкти\nотримуються тоді, коли код уперше звертається до атрибута. Документація прямо\nназиває наслідок: для N завантажених об'єктів звернення до їхніх ліниво\nзавантажуваних атрибутів дає N+1 інструкцій `SELECT`. Приклад нижче припускає,\nщо класи `Author` і `Book` уже відображено зі зв'язком один-до-багатьох\n`Author.books`, і проходить авторами трьома способами.\n\n```python\nfrom sqlalchemy import select\nfrom sqlalchemy.orm import raiseload, selectinload\n\n# За замовчуванням: один SELECT для авторів, а потім ще по одному\n# для кожного автора, чиї книжки зачіпає цикл, разом N+1 інструкцій.\nauthors = session.scalars(select(Author)).all()\nfor author in authors:\n    print(author.name, len(author.books))\n\n# select IN: другий SELECT отримує книжки всіх авторів одразу,\n# з їхніми первинними ключами в умові IN.\nstmt = select(Author).options(selectinload(Author.books))\nfor author in session.scalars(stmt).all():\n    print(author.name, len(author.books))\n\n# raise: звернення до author.books тепер спричиняє помилку,\n# а не непомітно надсилає ще один запит.\nstmt = select(Author).options(raiseload(Author.books))\n```\n\nДля колекцій один-до-багатьох і багато-до-багатьох документація називає\n`selectinload()` загалом найкращою стратегією. `joinedload()`, яку вона називає\nнайуніверсальнішою, додає `JOIN` до початкової інструкції, за замовчуванням\n`LEFT OUTER JOIN`, тож пов'язані рядки приходять в одному наборі результатів.\n`raiseload()` існує, щоб захищати від небажаних завантажень, а її форма з\nсимволом підстановки, `raiseload(\"*\")`, поширює цей захист і на інші зв'язки,\nзокрема на зв'язки об'єктів, які інструкція таки завантажує.\n\nDjango 6.1 дає тому самому вибору власну назву: fetch modes, режими отримання.\nКоли код звертається до поля, якого початковий запит не завантажив, наприклад до\nзовнішнього ключа, зв'язку один-до-одного або поля, пропущеного через `defer()`\nчи `only()`, режим за замовчуванням `FETCH_ONE` отримує його лише для цього\nодного екземпляра, і документація сама називає наслідок проблемою N+1 запитів.\n`FETCH_PEERS`, новий у 6.1, отримує відсутнє поле для цього екземпляра й для\nвсіх інших екземплярів із того самого `QuerySet`, виходячи з того, що коду,\nякому поле потрібне для одного рядка, зазвичай потрібне воно й для решти.\n`FETCH_RAISE` натомість спричиняє `FieldFetchBlocked`. Режим задають для\nокремого `QuerySet`, як у `Book.objects.fetch_mode(models.FETCH_PEERS)`, або як\nтиповий для моделі через власний менеджер, і Django копіює його на пов'язані\nоб'єкти, які отримує. Там, де `FETCH_PEERS` не підходить або недостатньо\nефективний, посібник з оптимізації радить `select_related()` і\n`prefetch_related()`.\n\nВласні сторінки компанії проводять цю межу ближче до бази даних, ніж більшість.\n[Сторінка технологій](/uk/tech-stack/) розглядає SQL як повноцінну мову, а не\nте, що генерує ORM, бо саме там здебільшого лежить робота з продуктивністю,\nзаради якої компанію запрошують. Під час роботи в NextMariner засновниця довела\nцю думку до кінця й\n[спроєктувала функційний рівень даних PostgreSQL](/uk/portfolio/designed-a-function-first-postgresql-data-layer/):\nкожна операція застосунку — це одна з 1 275 збережених функцій у 34 схемах, і\nпрямого доступу до таблиць із Go немає взагалі. Роль, від імені якої API входить\nу базу, має привілей `EXECUTE` для цих функцій і `USAGE` для їхніх схем — і\nбільше нічого, тож напряму звернутися до таблиці вона не може. Сторінка відверто\nназиває ціну: нове поле означає зміну і таблиці, і функції, а не ще один рядок у\nзапиті.\n\n## Де виникають проблеми\n\n**Цикл надсилає один запит на кожен рядок.** Описаний вище патерн N+1 здається\nнешкідливим на невеликій базі розробника, а потім сповільнює сторінку\nпропорційно до кількості рядків. Визначте спосіб завантаження для кожного\nважливого шляху в коді: `selectinload()` або `joinedload()` у SQLAlchemy,\n`FETCH_PEERS`, `select_related()` або `prefetch_related()` у Django. Потім\nзробіть так, щоб незапланований випадок падав гучно: `raiseload()` у SQLAlchemy\nабо `FETCH_RAISE`, який документація Django описує як спосіб запобігти\nненавмисним запитам у критичному до продуктивності коді.\n\n**Ніхто не читає SQL, який пише ORM.** ORM пише SQL, якого ніхто в команді не\nобирав, і цей SQL залишається невидимим, доки сторінка не почне гальмувати.\nПосібник Django з оптимізації починається саме з цього: з'ясуйте, які запити\nвиконує сторінка і скільки вони коштують, скористайтеся `QuerySet.explain()`,\nщоб побачити, як база виконує певний `QuerySet`, і прочитайте\n`django.db.connection.queries`, щоб побачити, що Django пише від імені коду.\nЗробіть читання цього SQL сталою частиною рев'ю кожної важливої сторінки чи\nзадачі, а повільні інструкції проганяйте через план запиту самої бази.\n\n**Робота, якій місце в базі, виконується в Python.** Завантажувати рядки лише\nдля того, щоб відфільтрувати їх, порівняти два їхні поля чи підсумувати, означає\nпереносити кожен рядок через з'єднання, щоб у коді застосунку зробити те, що\nбаза могла б зробити там, де дані вже лежать. Посібник Django перелічує\nальтернативи: `filter()` і `exclude()` для фільтрування в базі, вирази `F()` для\nпорівняння полів у межах однієї моделі та `annotate()` для агрегування в базі.\nЗаписування підпорядковується тому самому правилу: `bulk_create()` і\n`bulk_update()` замість окремого `save()` для кожного об'єкта, після перевірки\nзастережень, які документація наводить для обох. Для дуже великого набору\nрезультатів `QuerySet` тримає все, що прочитав, і може займати багато пам'яті, і\nтоді може допомогти `iterator()`.\n\n**Останню частину проштовхують крізь ORM.** Власна оцінка Фаулера залишає від 10\nдо 20% задач відображення, і ця остання частина, за його словами, завжди\nпотребує ретельної роботи. Якщо гнути ORM, доки вона не видасть певну\nінструкцію, ця робота ховається в згенерованому SQL, якого ніхто не обирав.\nПишіть такі інструкції на SQL і переглядайте їх, як будь-який інший код.\nПосібник Django називає щаблі вниз: вираз `RawSQL` додає до запиту явний SQL,\nменш переносний, але потужніший, а далі команда може писати власний SQL, щоб\nотримувати дані або заповнювати моделі. Залишайте ORM для рутинних записів, де\nвона заощаджує найбільше й коштує найменше.\n\n## Що почитати далі\n\n- [Catalog of Patterns of Enterprise Application Architecture](https://martinfowler.com/eaaCatalog/)\n  — короткі описи Active Record, Data Mapper, Unit of Work, Identity Map і Lazy\n  Load від Мартіна Фаулера.\n- [ORM Hate](https://martinfowler.com/bliki/OrmHate.html)\n  — чому об'єктно-реляційне відображення складне і скільки з нього може взяти на\n  себе фреймворк.\n- [Relationship Loading Techniques](https://docs.sqlalchemy.org/en/21/orm/queryguide/relationships.html)\n  — ліниве завантаження, select IN, joined і raise у SQLAlchemy 2.1 та вибір між\n  ними.\n- [Fetch modes](https://docs.djangoproject.com/en/stable/topics/db/fetch-modes/)\n  — `FETCH_ONE`, `FETCH_PEERS` і `FETCH_RAISE`, нові в Django 6.1.\n- [Database access optimization](https://docs.djangoproject.com/en/stable/topics/db/optimization/)\n  — профілювання, обчислення `QuerySet`, робота в базі, пакетні методи й сирий\n  SQL.\n\n\u003chttps://engineer.company/uk/glossary/orm/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Що робить ORM між об'єктами й таблицями, з яких патернів Фаулера складається, скільки коштує завантаження пов'язаних рядків і чотири типові пастки.","formats":{"gemtext":"https://engineer.company/uk/glossary/orm/index.gmi","gopher":"https://engineer.company/uk/glossary/orm/gophermap","html":"https://engineer.company/uk/glossary/orm/","json":"https://engineer.company/uk/glossary/orm/index.json","markdown":"https://engineer.company/uk/glossary/orm/index.md","pdf":"https://engineer.company/uk/glossary/orm/index.pdf"},"kind":"page","language":"uk","title":"Що таке ORM?","url":"https://engineer.company/uk/glossary/orm/","version":1}