doctrine-batch-processing — Claude Code skill for Doctrine batches
doctrine-batch-processing is a Claude Code skill for processing large Doctrine datasets in memory-conscious imports, exports, and backfills.
MIT ★ 234 updated 2026-10-05
npx skills add dev-toolings/superpowers-symfony --skill doctrine-batch-processing -a claude-codeWhat doctrine-batch-processing does
The skill starts with measuring the dataset and the process memory budget. It recommends streaming entities with toIterable() or paging through very large tables by ID. Flush and clear after a chosen batch size, then load again any entities needed after clearing.
For bulk changes, it weighs ORM against DQL and DBAL when entity hydration is unnecessary. Those bulk paths bypass lifecycle events and listeners, so check whether your application relies on them. ORM 3 calls for toIterable() rather than Query#iterate(); use logging middleware in place of setSQLLogger().
Avoid findAll() on a table that keeps growing. The skill also calls for an explicit batch size and clear points, memory measurements on a realistic dataset, and a resumable run.
What it helps with
- stream an import that exceeds available memory
- export a large table without loading every entity
- update or delete many rows with bulk DQL
- insert large volumes through Doctrine or DBAL
- make a batch run resumable after interruption
Example prompts for the agent
- Process this import in Doctrine batches and record memory before and after the run.
- Build an export for a large table with
toIterable()and clear the EntityManager between batches. - Choose ORM, DQL or DBAL for this bulk update and account for lifecycle events.
How to install doctrine-batch-processing
1Skills CLI (Vercel)
npx skills add dev-toolings/superpowers-symfony --skill doctrine-batch-processing -a claude-code2Manually: put the files in place
~/.claude/skills/doctrine-batch-processing/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/doctrine-batch-processing/
1Skills CLI (Vercel)
npx skills add dev-toolings/superpowers-symfony --skill doctrine-batch-processing -a codex2Manually: put the files in place
.agents/skills/doctrine-batch-processing/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add dev-toolings/superpowers-symfony --skill doctrine-batch-processing -a cursor2Manually: put the files in place
.cursor/skills/doctrine-batch-processing/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install dev-toolings/superpowers-symfony content/skills/doctrine-batch-processing2Manually: put the files in place
.github/skills/doctrine-batch-processing/SKILL.md1Skills CLI (Vercel)
npx skills add dev-toolings/superpowers-symfony --skill doctrine-batch-processing -a gemini-cli2Platform CLI
gemini skills install https://github.com/dev-toolings/superpowers-symfony --path content/skills/doctrine-batch-processingManually: put the files in place
.devin/skills/doctrine-batch-processing/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about doctrine-batch-processing
How do I install doctrine-batch-processing in Claude Code?
Run npx skills add dev-toolings/superpowers-symfony --skill doctrine-batch-processing -a claude-code. The skill file is at ~/.claude/skills/doctrine-batch-processing/SKILL.md.
What does doctrine-batch-processing do?
It guides large-data workflows in Doctrine: streaming or ID-based reads, periodic flush and clear, and choosing ORM, DQL or DBAL for writes. It also covers memory checks and operational safeguards.
Why does the skill recommend paging by ID instead of offset?
Offsets can slow down and skip rows as the dataset changes. Paging by ID avoids those issues described in the skill.
Source text
SKILL.md · MIT
--- name: doctrine-batch-processing description: Process large datasets with Doctrine (ORM 3 toIterable, flush+clear, bulk DQL) and memory management capabilities: [read, search, edit, shell] tags: [doctrine, performance] # projected by `bun run build` — do not edit by hand allowed-tools: - Read - Glob - Grep - Write - Edit - Bash --- # Doctrine Batch Processing (Symfony) ## Use when - Processing more rows than fit in memory: imports, exports, backfills. - A command or worker runs out of memory iterating over entities. - Updating or deleting many rows at once. - Inserting large volumes through Doctrine or DBAL. ## Default workflow 1. Measure the dataset size and the memory budget of the process. 2. Stream reads with `toIterable()`, or paginate by id (`id > :lastId`) for very large tables. 3. Flush and `clear()` every N items, and re-fetch anything needed after a clear. 4. Use DQL `UPDATE`/`DELETE` or DBAL for bulk writes that need no hydration. 5. Log memory usage and progress, and make the run resumable. ## Guardrails - Never `findAll()` on a table that grows. - Entities loaded before a `clear()` are detached: do not modify or persist them. - Bulk DQL and DBAL skip lifecycle events and listeners. Check what relies on them. - On ORM 3, `Query#iterate()` and `setSQLLogger()` are gone: use `toIterable()` and a logging middleware. - Paginate by id rather than by offset: offsets get slower and skip rows when data moves. ## Progressive disclosure - Use this file for execution posture and risk controls. - Open references when deep implementation details are needed. ## Output contract - A batch loop with an explicit batch size and clear points. - The choice between ORM, DQL bulk and DBAL for each write, with the reason. - Memory measurements before and after on a realistic volume. ## References - `reference.md`
© dev-toolings · MIT · dev-toolings/superpowers-symfony