PHP a databáze

Integrace databází a ORM v PHP

Integrace databází je v PHP ekosystému jedním z nejčastějších úkolů. Volba přístupu – od „čistého“ PDO přes query builder až po plnohodnotné ORM (Object–Relational Mapping) – zásadně ovlivňuje bezpečnost, výkon, udržovatelnost i rychlost vývoje. Tento článek shrnuje architektonické styly, klíčové koncepty ORM, výhody a nevýhody různých přístupů, best practices, výkonové optimalizace a specifika nejrozšířenějších frameworků (Laravel, Symfony, Nette, Laminas, Yii).

Architektonické styly práce s databází

• PDO (low-level přístup): Ruční psaní SQL, připravené dotazy, plná kontrola nad výkonem i transakcemi. Vhodné pro vysoce optimalizované části, reporting a složité dotazy.
• Query Builder: Fluent API pro skládání SQL (dbal, Eloquent Builder, Nette\Database\Explorer, Laminas\Db\Sql). Snižuje riziko chyb a čitelnost zvyšuje, ale stále zachovává blízkost SQL.
• ORM: Mapování tabulek na entity a vztahy, Unit of Work, Identity Map, lazy/eager loading, migrace. Typicky Doctrine ORM (Symfony), Eloquent (Laravel), Cycle ORM, Propel, Atlas.

Vzory ORM: Active Record vs. Data Mapper

• Active Record: Třída entity nese metody save(), find(), delete() (např. Eloquent, Yii AR). Jednodušší pro CRUD, hůř škáluje na komplexní domény.
• Data Mapper: Oddělení doménového modelu od perzistence (např. Doctrine). Vyšší flexibilita pro DDD, složitější konfigurace.

Klíčové koncepty ORM

• Entity a hodnotové objekty: Entity mají identitu (primární klíč), value objekty jsou neidentitární a neměnné.
• Unit of Work a Identity Map: Sledování změn nad entitami, zabránění duplicitním instancím jednoho řádku.
• Vztahy: OneToOne, OneToMany, ManyToMany; kardinality a vlastnictví vztahu (owning/inverse side) ovlivňují generované SQL.
• Načítání dat: Lazy vs. eager loading; join fetch, select in, subselect strategie.
• Životní cyklus entity: stavy new, managed, detached, removed; události (prePersist, postLoad…).

Bezpečnost: SQL injection a práce s daty

• Připravené dotazy: Vždy používejte parametrizaci (?/:name), nikdy neskádejte SQL stringem z neověřených vstupů.
• Escapování vs. parametrizace: Parametrizace má přednost; escapování je doplňkové a chybové scénáře se mohou lišit napříč ovladači.
• Serializace JSON/XML: Při ukládání dokumentů do sloupců používejte validaci schématu, velikostní limity a indexy (např. GIN pro JSONB).
• Least privilege: Aplikační účet s omezenými právy (SELECT/INSERT/UPDATE/DELETE pro konkrétní schéma), oddělené uživatelské role pro migrace.

Transakce a izolace

• Granularita: Obalujte logické jednotky práce (service nebo use-case) do transakcí; v Orm používejte EntityManager::transactional() (Doctrine) či DB::transaction() (Laravel).
• Izolační úrovně: READ COMMITTED, REPEATABLE READ, SERIALIZABLE; volba ovlivňuje riziko „phantoms“, „non-repeatable reads“.
• Deadlocky: Implementujte idempotentní retry s exponenciálním zpožděním a auditováním.

Migrace schématu a verzování

• Nástroje: Doctrine Migrations, Laravel Migrations, Phinx; verzujte spolu s kódem a CI/CD.
• Bezvýpadkové změny: Přidávejte nové sloupce jako NULL/s defaultem, provádějte backfill v dávkách, poté zpřísněte NOT NULL.
• Seed/fixtures: Deterministická testovací data; oddělujte dev seed od produkční inicializace.

Výkon a optimalizace (ORM i SQL)

• N+1 dotazů: Používejte eager loading (with() v Eloquent, JOIN FETCH v Doctrine) a dávkové načítání (batching).
• Indexy: Měřte a přidávejte kompozitní indexy dle reálných dotazů; sledujte EXPLAIN plány.
• Pagination a streaming: Keyset pagination (přes >/<) je efektivnější než OFFSET pro velké tabulky; využijte kurzory.
• Kešování: Aplikační cache (Redis, Memcached), 2nd-level cache (Doctrine), query cache tam, kde je to bezpečné.
• Bulk operace: Dávkové insert/update s vypnutím sledování změn v ORM (clear, detach) a využitím native queries pro masivní operace.
• Asynchronní běh: V kombinaci se Swoole/RoadRunner využijte persistentní připojení a pooly; dejte pozor na stavovost objektů ORM mezi požadavky.

Doménové modelování a repozitáře

• Repository pattern: Zapouzdřuje dotazy nad agregáty, udržuje kontrakt domény; v Doctrine lze implementovat vlastní Repository třídy.
• Specifikace a CQRS: Těžké čtecí dotazy přesuňte do read-modelů (DTO/projekce) a oddělte od zápisového modelu.
• Event sourcing: V doménách s auditem zvažte ukládání událostí; projekce denormalizujte do tabulek pro čtení.

Podpora typů a moderní PHP

• Typed properties a readonly: Zvyšují spolehlivost entit; vyžadují opatrnost při lazy-loading proxích.
• Enum a backed enum: Mapujte na malé tabulky či ENUM sloupce; v Doctrine/Eloquent jako custom typy/CASTy.
• Atributy: Konfigurace ORM přes PHP atributy místo anotací/doktrínských YAML; přehlednější a typově bezpečnější.
• Statická analýza: Psalm/PHPStan s generiky (phpdoc) pro kolekce; chytá nekompatibility dotazů ještě před nasazením.

Práce s více databázemi, replikace a škálování

• Read/Write splitting: Zápisy na master, čtení z replik; pozor na replication lag a konzistenci po zápisu (sticky sessions, read your write).
• Sharding: Logická distribuce dat (uživatelé, tenanti) podle klíče; repozitáře rozhodují o shardu.
• Multi-tenant: Izolace per tenant (schéma/tabulky) vs. sdílené tabulky s tenant_id a row-level security.

Práce s NoSQL a speciálními typy

• JSON/JSONB: Mapujte na DTO a validujte; indexy pro často dotazované cesty (->, ->>, #>).
• Geodata: PostGIS; v Doctrine vlastní typy pro geometry, v Eloquent casty a SRID kontrola.
• Fulltext: MySQL InnoDB FULLTEXT/Boolean mode nebo specializovaný vyhledávač (OpenSearch, Meilisearch) se synchronizací událostí.

Zpracování změn: concurrency a audit

• Optimistická zámky: Sloupec version/updated_at pro detekci konfliktů; ORM vyhodí výjimku při kolizi.
• Pessimistické zámky: SELECT ... FOR UPDATE pro kritické sekce; nezapomeňte na timeouty.
• Audit trail: Listeners/subscribers logují změny; ukládejte dify nebo celé snímky podle potřeby.

Testování a izolace

• Transaction per test: Obalte test do transakce a na konci rollback; rychlé a izolované.
• Fixtures a factories: Vytvářejte data skrze doménové API; nepřeskakujte validační logiku.
• Integration vs. unit: Složitější dotazy testujte integračně proti skutečné DB (např. v kontejnerech), doménu unit-testy se stuby repozitářů.

Integrace ve frameworkách

• Laravel (Eloquent): Active Record, migrations, seeder, factories, globální/scoped query, casts, události modelů; snadné eager loading a withCount().
• Symfony (Doctrine ORM): Data Mapper, EntityManager, Repository, QueryBuilder, hydrátory, 2nd-level cache; silný ekosystém nástrojů.
• Nette (Database/Explorer, Doctrine integration): Lehký query builder a mapování na row objekty; pro DDD se často kombinuje s Doctrine.
• Laminas (Db): SQL builder, adaptery, TableGateway; vhodné pro projekty preferující explicitní SQL.
• Yii (Active Record): Podobné Eloquentu s propracovaným with() a scénáři validace.

Logování a observabilita

• SQL log: Zapněte logování dotazů s parametry a trváním; v produkci s rozmyslem (sampling).
• Tracing: OpenTelemetry/Jaeger; anotujte boundary (repozitáře, transakce), přidejte DB span atributy (db.system, statement, rows).
• Performance budget: Definujte SLA pro latenci dotazů a počet round-tripů na request.

Typické anti-patterny a jak se jim vyhnout

• Mass assignment bez whitelistu: V Eloquent používejte $fillable/$guarded; v Doctrine validujte DTO před hydratací.
• Business logika v kontrolerech: Přesuňte do služeb a domén; kontroler volá use-case.
• N+1 a eager loading všude: Vždy měřte; někdy je lepší explicitní SQL s agregací.
• Neřízené lazy-loading v šablonách: Generuje nestabilní latenci; připravte data v aplikační vrstvě.

Roadmapa implementace v projektu

1. Volba přístupu: Definujte, kde použijete ORM, kde query builder a kde nativní SQL.
2. Model a hranice: Navrhněte entity, agregáty, repozitáře, transakční hranice a politiky načítání.
3. Migrace a seed: Nastavte nástroje, konvence verzování a CI pipeline pro migrační kroky.
4. Bezpečnost: Parametrizace, role DB, audit dotazů a přístupů, testy injekcí.
5. Výkon: Indexy, eager loading, cache, keyset pagination, sledování plánů.
6. Testy: Strategy pro unit/integrace, transakční testy, fixtures.
7. Observabilita: Log SQL, tracing, metriky a alerting.

Tabulkové srovnání přístupů

Závěr

Úspěšná integrace databází v PHP spočívá v promyšlené kombinaci nástrojů a přístupů. ORM výrazně zvyšuje produktivitu a udržovatelnost, ale vyžaduje znalost jeho interních mechanismů (Unit of Work, načítací strategie, transakce). Když jde o výkon, je legitimní sáhnout po query builderu či čistém SQL – zásadní je měřit, profilovat a mít jasné architektonické hranice. S moderními možnostmi PHP (typy, enumy, atributy), s disciplínou v migracích, testech a observabilitě lze vybudovat robustní datovou vrstvu, která obstojí jak v rychlém vývoji, tak ve vysokém zatížení produkce.