DataHandler Performance in TYPO3 v13 & v14: Benchmark Update

Abstract  

Following our initial DataHandler analysis for TYPO3 v12, we take a quantitative look at the evolution of the core persistence engine in v13 LTS and the v14 development branch. The fundamental architecture as a stateful, integrity-focused gatekeeper remains intact – however, both versions introduce subtle yet 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.

Through replicated 10,000-record import benchmarks across both versions, we demonstrate: These changes improve code health and consistency – whilst the core performance profile for bulk operations remains stable. The results confirm based on data: Batch processing and programmatic feature toggling are not mere optimisations, but essential best practices yielding performance gains of over 90%, regardless of the TYPO3 version. The path to efficient bulk data operations in modern TYPO3 versions involves working with the stateful design of the DataHandler – not against it.

Table of Contents  

I. Introduction: The Core Persistence Engine Revisited  

Our v12 analysis established: The TYPO3 DataHandler prioritises data integrity over raw throughput. Its monolithic, stateful nature generates significant overhead during bulk operations – a challenge that can be overcome with strategies such as batch processing. With the evolution of the TYPO3 Core, we are evaluating these findings in the context of newer versions. This report expands our investigation to TYPO3 v13 LTS and the main development branch, which will become TYPO3 v14.

The primary objective: to examine whether architectural changes, bug fixes, or new features in these versions have noticeably altered the performance profile of the DataHandler 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 the validity and comparability of our findings, we set up a consistent, fully automated testing environment using DDEV. This enables rapid provisioning of isolated TYPO3 v13 and v14 instances – meaning each 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  

Separate DDEV configurations were created 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 defines 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 execute each benchmark three times – taking the median value ensures stability.

III. TYPO3 v13 LTS: Evolutionary Improvements  

3.1 Core Changes with Performance Relevance  

TYPO3 v13 does not introduce a radical DataHandler refactoring, but 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:

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

Doctrine DBAL Optimisations:

• Query builder 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  

Using identical optimisations as in 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 performance multiplier – regardless of the choice between v12 and v13.

IV. TYPO3 v14 Development Branch: Breaking Changes  

4.1 Architectural Evolution  

TYPO3 v14 continues the cleanup process – with several breaking changes:

Removed Deprecated Properties:

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

Hook removal completed:

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

Persistence Initiative Progress:

• First steps towards service separation are visible
• Internal refactoring for future decoupling
• Impact: No performance relevance yet

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 – however, the difference remains in the single-digit percentage range.

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, but 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 – regardless of the core version.

5.3 Cross-Version Optimisation Performance  

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

VI. Architectural Insights: Why Performance Remains Stable  

6.1 The Stateful Design Remains Intact  

The core bottlenecks of the DataHandler – state accumulation, per-record overhead, cache flushing – exist 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 lifetime 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 across all versions.

6.2 Batch Processing as an Architectural 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: A Performance Perspective  

Migrating from v12 to v13:

• Performance gain: Marginal (< 2%)
• Code changes: None for DataHandler bulk operations
• Migration effort: Low (Backward 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 is working on 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 will be able to build custom pipelines – using only the required services and avoiding unnecessary overhead.

8.2 Timeline & Expectations  

Realistic Forecast:

• TYPO3 v14: First internal refactorings, 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 deliver 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. Stable architecture: The stateful design of the DataHandler remains unchanged in v13/v14.
4. Universal best practices: Optimisation code from v12 functions without changes in v13/v14.
5. Future direction: The Persistence Initiative is working towards a decoupled architecture – Timeline: v15+.

9.2 Recommendations for Action  

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