Download the PHP package ecourty/doctrine-export-bundle without Composer
On this page you can find all versions of the php package ecourty/doctrine-export-bundle. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.
Informations about the package doctrine-export-bundle
Doctrine Export Bundle
A flexible and extensible Symfony bundle for exporting Doctrine entities to various formats (CSV, JSON, XML).
Compatible with PHP 8.3+, Symfony 7.x/8.x, and Doctrine ORM 3.x/4.x 🎉
📖 Table of Contents
- Installation
- Quick Start
- Key Features
- Performance
- Usage
- Basic Export to File
- Streaming Export (Binary Response)
- Advanced Options
- Custom Entity Processors
- Field Selection
- Export Options
- Field Validation
- Memory Management
- Association Handling
- Events
- Supported Formats
- Development
- Requirements
- License
Installation
If you're not using Symfony Flex, enable the bundle manually:
Quick Start
Export entities in a few lines:
That's it! 🚀
✨ Key Features
- 🎯 Field Selection - Export only the fields you need
- 🔍 Advanced Filtering - Filter by criteria, pagination, ordering
- 📦 Multiple Formats - CSV, JSON, XML out of the box
- 💾 Memory Efficient - Streaming support via generators (< 5 MB for 100k entities)
- ⚡ High Performance - 42,000 entities/second (JSON), linear O(n) scaling
- 🔌 Extensible - Add custom formats with the Strategy pattern
- 🎯 Type-Safe - PHP 8.1+ enums for format specification
- 🛡️ XML Native - Uses XMLWriter for guaranteed valid XML
Performance
Benchmarked with realistic dataset (10,000 entities, 15 fields):
| Format | Time (10k entities) | Memory Usage | Throughput |
|---|---|---|---|
| CSV | 0.274s | 2.00 MB | 36,496 ent/s |
| JSON | 0.238s | < 0.1 MB | 42,017 ent/s |
| XML | 0.314s | < 0.1 MB | 31,847 ent/s |
| Generator | 0.305s | < 0.1 MB | 32,787 ent/s |
Tested: 10,000 entities × 15 fields = 150,000 data points
Linear scaling: tested with 100,000 entities in ~2.5s with < 5 MB memory 🚀
Usage
Basic Export to File
Streaming Export (Binary Response)
Simply pass the generator to a StreamedResponse:
Events
The bundle dispatches events before and after each export, allowing you to hook into the export lifecycle for logging, monitoring, or custom logic.
Events are optional - if no event dispatcher is configured, exports work normally without events.
The bundle uses the PSR-14 EventDispatcherInterface (Psr\EventDispatcher\EventDispatcherInterface), making it compatible with any PSR-14 compliant event dispatcher, not just Symfony's.
Available Events
PreExportEvent- Dispatched before export beginsPostExportEvent- Dispatched after export completes (includes count and duration)
Example: Logging Exports
Example: Performance Monitoring
Event Properties
PreExportEvent:
getEntityClass()- Entity class being exportedgetFormat()- Export format (CSV, JSON, XML)getCriteria()- Filter criteriagetLimit()- Result limitgetOffset()- Result offsetgetOrderBy()- Sort ordergetFields()- Selected fieldsgetOptions()- Export options
PostExportEvent:
- All PreExportEvent properties
getExportedCount()- Number of entities exportedgetDurationInSeconds()- Export duration measured with microsecond precision (float)
Supported Formats
| Format | Extension | Description | Use Case |
|---|---|---|---|
| CSV | .csv |
Comma-separated values | Spreadsheets, Excel |
| JSON | .json |
JSON format | APIs |
| XML | .xml |
XML with configurable structure | Legacy enterprise systems |
Format Examples
Advanced Options
Custom Entity Processors
Implement custom data transformations with entity processors. They allow you to modify exported data, add virtual fields, or apply business logic during export.
Creating a Custom Processor
Using Processors
Adding Virtual Fields
Chaining Multiple Processors
Processors are executed in order, allowing you to compose transformations:
Performance Optimization: Disable Default Processor
When using a fully custom processor that handles all data extraction, disable the default processor for better performance:
Note: The default processor handles property access, associations, and data normalization. Only disable it when your custom processor fully replaces this functionality.
Field Selection
You can specify which fields to export. If not specified, all entity fields are exported:
Note: Field names are validated against the entity metadata. If you specify a field that doesn't exist, an InvalidCriteriaException will be thrown.
Export Options
Available Options
| Option | Type | Default | Description |
|---|---|---|---|
OPTION_BOOLEAN_TO_INTEGER |
bool |
true |
Convert boolean values to integers (1/0) instead of strings ('true'/'false') |
OPTION_DATETIME_FORMAT |
string |
DateTimeInterface::ATOM |
PHP date format for DateTime fields (e.g., 'Y-m-d H:i:s', 'c') |
OPTION_NULL_VALUE |
string\|int\|float |
null |
Custom representation for null values (e.g., 'NULL', 'N/A', '') |
OPTION_STRICT_FIELDS |
bool |
false |
Throw exception if a requested field doesn't exist on the entity |
OPTION_DISABLE_DEFAULT_PROCESSOR |
bool |
false |
Skip default processor when using custom processors that handle all processing |
Field Validation
The bundle automatically validates that fields in criteria and orderBy exist in the entity. If an invalid field is specified, an InvalidCriteriaException will be thrown with a helpful error message listing all available fields.
Memory Management
The bundle uses streaming and entity detachment for automatic memory efficiency:
How it works:
- Uses Doctrine's
toIterable()for true streaming (one entity at a time) - Each entity is detached immediately after processing
- Detachment is safe: only affects memory tracking, not your database
- No
clear(), noflush(), no batch management needed - PHP's garbage collector handles memory automatically with the streaming approach
Why no batching? This bundle doesn't need batch processing because:
- Entities are processed one-by-one (real streaming)
- Each entity is detached immediately (no accumulation)
- Generators ensure minimal memory footprint naturally
- No circular references are created
Association Handling
Doctrine associations are automatically exported as primary keys:
How it works:
- ManyToOne / OneToOne: Exported as the related entity's primary key (integer or string)
- ManyToMany / OneToMany: Exported as an array of primary keys
[1, 2, 3] - Null associations: Exported as
null - Collections: Empty collections exported as
[] - No lazy loading issues: Primary keys are extracted without triggering proxy initialization
- Format-specific rendering: JSON keeps arrays native, CSV/XML encode as JSON string
Benefits:
- Avoids N+1 queries and lazy loading issues
- Keeps export lightweight and predictable
- Easy to re-hydrate entities on import if needed
- Works seamlessly with all export formats
Development
Quality Assurance
Run all quality checks:
Individual commands:
Requirements
- PHP 8.3 or higher
- Symfony 7.0 or 8.0
- Doctrine ORM 3.0 or 4.0
License
MIT
All versions of doctrine-export-bundle with dependencies
ext-xmlwriter Version *
symfony/config Version ^7.0|^8.0
symfony/dependency-injection Version ^7.0|^8.0
symfony/http-kernel Version ^7.0|^8.0
symfony/property-access Version ^7.0|^8.0
doctrine/orm Version ^3.0|^4.0
doctrine/doctrine-bundle Version ^2.18|^3.1
psr/event-dispatcher Version ^1.0