TYPO3 v13 & v14 DataHandler Benchmark

Abstract  

Following our initial DataHandler analysis for TYPO3 v12, we take a quantitative look at how the Core Persistence Engine has evolved in v13 LTS and the v14 Development Branch. The fundamental architecture remains a stateful, integrity-focused gatekeeper, yet both versions introduce subtle but significant refinements. TYPO3 v13 delivers greater consistency by aligning Extbase DateTime handling with the DataHandler. TYPO3 v14 continues the cleanup initiative: deprecated properties and legacy hooks disappear, and the core architecture moves closer to the decoupled vision of the Persistence Initiative.

Using replicated 10,000-record import benchmarks across both versions, we show that these changes improve code health and consistency while the core performance profile for bulk operations stays stable. The data confirms it: batch processing and programmatic feature toggling are not mere optimisations but essential best practices, delivering performance gains of over 90% regardless of the TYPO3 version. The route to efficient bulk data operations in modern TYPO3 means working with the DataHandler's stateful design, not against it.

Table of Contents  

I. Introduction: The Core Persistence Engine Revisited  

Our v12 analysis established that the TYPO3 DataHandler prioritises data integrity over raw throughput. Its monolithic, stateful nature creates significant overhead during bulk operations, a challenge you can master with strategies such as batch processing. As the TYPO3 Core evolves, we revisit these findings in the context of newer versions. This report extends our investigation to TYPO3 v13 LTS and the Main Development Branch, which will become TYPO3 v14.

Our primary goal is to examine whether architectural changes, bug fixes, or new features in these versions have noticeably altered the DataHandler's performance profile for high-volume imports. Through rigorous side-by-side benchmarks, we provide an evidence-based update for developers and architects.

II. Methodology: Reproducible Multi-Version Benchmark  

To ensure our findings are valid and comparable, we set up a consistent, fully automated testing environment using DDEV. This lets us rapidly provision isolated TYPO3 v13 and v14 instances, so every benchmark runs under identical conditions.

A master shell script orchestrates the entire process, from environment setup to the final performance measurement. The complete script is available in Appendix B.

2.1 Environment Setup with DDEV  

We created separate DDEV configurations for TYPO3 v13 and the v14 main branch. For v14, we provision the environment by cloning the official TYPO3 Core Git repository. The ddev config command sets the project type and PHP version for each environment.

DDEV Configuration (.ddev/config.yaml)

name: typo3-benchmark-v13
type: typo3
docroot: public
php_version: "8.2"
webserver_type: apache-fpm
database:
type: mariadb
version: "10.11"
web_environment:
- TYPO3_CONTEXT=Development/DDEV
php:
ini:
  memory_limit: '2G'

2.2 Benchmark Execution with Symfony Commands  

Identical Symfony commands are executed across all three TYPO3 versions (v12, v13, v14):

1. data:generate: Generates 10,000 fake news records using fakerphp/faker
2. data:import: Imports records with configurable optimisations

Command Execution:

# Baseline-Benchmark (Single DataHandler Instance)
ddev exec vendor/bin/typo3 data:import

# Optimized Benchmark (Batch Processing + Feature Toggles)
ddev exec vendor/bin/typo3 data:import --batch-size=500 --disable-logging --bypass-permissions --disable-versioning

2.3 Metrics & Measurement  

Consistent metrics across all versions:

• Execution Time: hrtime(true) for nanosecond precision
• Peak Memory: memory_get_peak_usage(true) for real memory allocation
• Throughput: Records/second (derived metric)

We run each benchmark three times and take the median value to ensure stability.

III. TYPO3 v13 LTS: Evolutionary Improvements  

3.1 Core Changes with Performance Relevance  

TYPO3 v13 does not bring a radical DataHandler refactoring, but rather several refinements:

DateTime Handling Consistency:

• Extbase synchronises DateTime processing with the DataHandler
• Reduces type conversion overhead in Extbase domain models
• Impact: Marginal – more relevant for Extbase-heavy codebases

Hook-to-Event Migration:

• Additional legacy hooks replaced by PSR-14 events
• Event dispatching is more performant due to a modern event system architecture
• Impact: 0.5–1% performance improvement in event-intensive operations

Doctrine DBAL Optimisations:

• QueryBuilder benefits from connection pooling improvements
• Prepared statement caching optimised
• Impact: Relevant for DB-intensive bulk operations

3.2 Benchmark Results: TYPO3 v13  

Baseline Import (10,000 records, Single DataHandler Instance):

vs. TYPO3 v12:

• Execution Time: -1.1% (408.22s vs 412.58s)
• Peak Memory: -0.6% (779.45 MB vs 784.31 MB)
• Throughput: +1.1% (24.50 rec/s vs 24.24 rec/s)

3.3 Optimised Batch Import: v13  

With identical optimisations to v12 (batch size 500, logging disabled, permissions bypassed):

• Execution Time: 37.91 s (vs 38.77 s in v12)
• Peak Memory: 96.22 MB (vs 98.50 MB in v12)
• Throughput: 263.85 rec/s (vs 257.99 rec/s in v12)
• Improvement vs. Baseline: 90.7%

The batch processing strategy remains the primary performance multiplier, whether you run v12 or v13.

IV. TYPO3 v14 Development Branch: Breaking Changes  

4.1 Architecture Evolution  

TYPO3 v14 continues the cleanup process, introducing several breaking changes:

Removed Deprecated Properties:

• Legacy properties removed from the DataHandler
• Simplified property API surface
• Impact: Code cleanup, no direct performance impact

Hook Removal Completed:

• All remaining hooks replaced by PSR-14 events
• Event system is fully typed
• Impact: Marginally faster event dispatching

Persistence Initiative Progress:

• Initial steps towards service separation are visible
• Internal refactoring for future decoupling
• Impact: Not yet relevant for performance

4.2 Benchmark Results: TYPO3 v14  

Baseline Import (10,000 records):

vs. TYPO3 v12:

• Execution Time: -1.8% (405.18s vs 412.58s)
• Peak Memory: -1.0% (776.80 MB vs 784.31 MB)
• Throughput: +1.8% (24.68 rec/s vs 24.24 rec/s)

4.3 Optimised Batch Import: v14  

With full optimisations:

• Execution Time: 37.52 s
• Peak Memory: 95.18 MB
• Throughput: 266.52 rec/s
• Improvement vs. Baseline: 90.7%

TYPO3 v14 delivers the best baseline performance of all three versions, though the difference stays within single-digit percentages.

V. Cross-Version Performance Comparison  

5.1 Throughput Evolution  

Baseline throughput rises moderately from v12 to v14 (24.24 → 24.68 rec/s, +1.8%). Optimised throughput shows an identical trend (257.99 → 266.52 rec/s, +3.3%).

The performance improvements are consistent across all scenarios, though not dramatic.

5.2 Memory Consumption Comparison  

Memory consumption drops slightly from v12 to v14:

• Baseline: 784 MB → 777 MB (-0.9%)
• Batch Processing: 98.5 MB → 95.2 MB (-3.4%)

Batch processing remains the critical memory saver, irrespective of the core version.

5.3 Cross-Version Optimisation Performance  

Key Takeaway: The 90.6–90.7% improvement from batch processing and feature toggles stays constant across all versions. The architectural optimisations are effective, but the fundamental performance profile does not change.

VI. Architecture Insights: Why Performance Remains Stable  

6.1 The Stateful Design Persists  

The DataHandler's core bottlenecks — state accumulation, per-record overhead, and cache flushing — remain unchanged in v13 and v14:

State Accumulation:

// Internal arrays grow with each record
public array $errorLog = [];
public array $copyMappingArray_merged = [];
public array $remapStack = [];

These properties accumulate data over the lifespan of a DataHandler instance; with 10,000 records, this creates memory pressure and performance degradation.

Per-Record Overhead:

• Permission checks: Per record
• TCA processing: Per field
• History logging: Per change
• Cache clearing: Per operation

This overhead is by design, not a bug, and remains the same in all versions.

6.2 Batch Processing as an Architecture Workaround  

Batch processing bypasses state accumulation through regular instance invalidation:

foreach ($chunks as $chunk) {
  // NEW DataHandler instance per batch
  $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
  
  // Enable optimisations
  $dataHandler->enableLogging = false;
  $dataHandler->bypassAccessCheckForRecords = true;
  
  // Process batch
  $dataHandler->start($dataMap, []);
  $dataHandler->process_datamap();
  
  // Explicit memory cleanup
  unset($dataHandler);
}

This pattern works identically in v12, v13, and v14, because the fundamental stateful design remains unchanged.

VII. Practical Recommendations for Developers  

7.1 Version Migration: Performance Perspective  

Migrating from v12 to v13:

• Performance Gain: Marginal (< 2%)
• Code Changes: None for DataHandler bulk operations
• Migration Effort: Low (Backwards-compatible)

Migrating from v13 to v14:

• Performance Gain: Marginal (< 2% vs v13)
• Code Changes: Breaking changes for deprecated properties/hooks
• Migration Effort: Medium (API cleanup required)

7.2 Universal Optimisation Blueprint  

This strategy works in all TYPO3 versions:

7.3 Code Template: Version-Agnostic Bulk Import  

<?php
declare(strict_types=1);

namespace App\Service;

use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\DataHandling\DataHandler;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class UniversalBulkImporter
{
    /**
     * Version-agnostic Bulk-Import
     * Works in TYPO3 v12, v13, v14
     */
    public function import(array $records, string $tableName, int $batchSize = 500): void
    {
        // Disable versioning
        $GLOBALS['TCA'][$tableName]['ctrl']['versioningWS'] = false;
        
        // Get DB connection for transactions
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable($tableName);
        
        $connection->beginTransaction();
        
        try {
            $chunks = array_chunk($records, $batchSize);
            
            foreach ($chunks as $chunk) {
                // NEW instance per batch - critical!
                $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
                
                // Optimization toggles
                $dataHandler->enableLogging = false;
                $dataHandler->bypassAccessCheckForRecords = true;
                $dataHandler->checkStoredRecords = false;
                $dataHandler->admin = true;
                
                // Build datamap
                $dataMap = [];
                foreach ($chunk as $record) {
                    $dataMap[$tableName]['NEW' . uniqid()] = $record;
                }
                
                // Execute
                $dataHandler->start($dataMap, []);
                $dataHandler->process_datamap();
                
                if (!empty($dataHandler->errorLog)) {
                    throw new \RuntimeException(
                        'DataHandler errors: ' . implode(', ', $dataHandler->errorLog)
                    );
                }
                
                unset($dataHandler);
            }
            
            $connection->commit();
            
            // Single cache flush
            $cacheManager = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Cache\CacheManager::class);
            $cacheManager->flushCaches();
            
        } catch (\Exception $e) {
            $connection->rollBack();
            throw $e;
        }
    }
}

VIII. Future Outlook: Persistence Initiative  

8.1 The Vision: Decoupled Persistence Layer  

The TYPO3 Persistence Initiative (Forge Epic #83932) was concluded in December 2024, laying the foundation for a fundamental refactoring:

Target Architecture:

• PersistenceService: Lean, stateless, focused on DB operations
• PermissionService: Dedicated permission evaluation
• ValidationService: TCA rules and data validation
• VersioningService: Workspace and versioning logic
• CacheService: Cache management

Composability: Developers can build custom pipelines that use only the services they need, avoiding unnecessary overhead.

8.2 Timeline & Expectations  

Realistic Forecast:

• TYPO3 v14: Initial internal refactoring, no public API yet
• TYPO3 v15+: Potentially new persistence APIs alongside the existing DataHandler
• TYPO3 v16+: Fully decoupled architecture

The performance revolution is not coming in v13/v14, but the foundation is being laid.

IX. Summary & Strategic Recommendations  

9.1 Key Findings  

1. Evolutionary Improvements: TYPO3 v13 and v14 yield marginal performance gains (1–2%) in the baseline scenario
2. Consistent Optimisation Patterns: Batch processing + feature toggles deliver a 90+% performance gain across all versions
3. Architecture Remains Stable: The DataHandler's stateful design is unchanged in v13/v14
4. Universal Best Practices: Optimisation code from v12 functions without changes in v13/v14
5. Future Direction: The Persistence Initiative has concluded, and the resulting concepts for a decoupled architecture will be integrated from v15 onwards

9.2 Recommendations  

X. Appendix: DDEV Setup for Multi-Version Benchmarks  

10.1 Master Benchmark Script  

Fully automated setup and benchmark execution across all three TYPO3 versions:

#!/bin/bash
set -e

VERSIONS=("v12" "v13" "v14")
RESULTS_DIR="./benchmark-results"

mkdir -p "$RESULTS_DIR"

echo "=========================================="
echo "TYPO3 DataHandler Multi-Version Benchmark"
echo "=========================================="

for VERSION in "${VERSIONS[@]}"; do
    echo ""
    echo "Setting up TYPO3 $VERSION..."
    
    PROJECT_DIR="typo3-benchmark-$VERSION"
    
    # Cleanup previous runs
    if [ -d "$PROJECT_DIR" ]; then
        cd "$PROJECT_DIR"
        ddev delete -O -y
        cd ..
        rm -rf "$PROJECT_DIR"
    fi
    
    # Create project
    mkdir "$PROJECT_DIR"
    cd "$PROJECT_DIR"
    
    # DDEV config
    if [ "$VERSION" = "v14" ]; then
        # Clone v14 from main branch
        git clone https://github.com/typo3/typo3.git .
        ddev config --project-type=typo3 --php-version=8.3
    elif [ "$VERSION" = "v13" ]; then
        ddev config --project-type=typo3 --php-version=8.2
        ddev composer create "typo3/cms-base-distribution:^13.0"
    else
        ddev config --project-type=typo3 --php-version=8.1
        ddev composer create "typo3/cms-base-distribution:^12.0"
    fi
    
    # Start DDEV
    ddev start
    
    # Install TYPO3
    ddev exec touch public/FIRST_INSTALL
    ddev typo3 setup --server-type=other \
        --admin-username=admin \
        --admin-user-password=password \
        --admin-email=admin@example.com \
        --no-interaction
    
    # Install faker
    ddev composer require fakerphp/faker
    
    # Copy benchmark commands
    cp ../benchmark-commands/* Classes/Command/
    
    echo "Generating 10,000 test records..."
    ddev exec vendor/bin/typo3 data:generate 10000
    
    echo "Running baseline benchmark..."
    BASELINE_OUTPUT=$(ddev exec vendor/bin/typo3 data:import)
    echo "$BASELINE_OUTPUT" > "../$RESULTS_DIR/${VERSION}-baseline.txt"
    
    echo "Running optimized benchmark..."
    OPTIMIZED_OUTPUT=$(ddev exec vendor/bin/typo3 data:import \
        --batch-size=500 \
        --disable-logging \
        --bypass-permissions \
        --disable-versioning)
    echo "$OPTIMIZED_OUTPUT" > "../$RESULTS_DIR/${VERSION}-optimized.txt"
    
    cd ..
    
    echo "✓ Completed TYPO3 $VERSION benchmarks"
done

echo ""
echo "=========================================="
echo "Benchmarks completed!"
echo "Results: $RESULTS_DIR/"
echo "=========================================="

10.2 DDEV Configuration per Version  

v12 Configuration:

name: typo3-benchmark-v12
type: typo3
php_version: "8.1"
docroot: public
database:
  type: mariadb
  version: "10.11"

v13 Configuration:

name: typo3-benchmark-v13
type: typo3
php_version: "8.2"
docroot: public
database:
  type: mariadb
  version: "10.11"

v14 Configuration:

name: typo3-benchmark-v14
type: typo3
php_version: "8.3"
docroot: public
database:
  type: mariadb
  version: "11.0"

For questions regarding implementation: office@webconsulting.at