Analyse der Leistung vom TYPO3 DataHandler: Viele Daten schnell verarbeiten

<?php
namespace TYPO3\CMS\Core\DataHandling;

class DataHandler
{
    // ============================================
    // WICHTIGE EIGENSCHAFTEN FÜR DIE LEISTUNG
    // ============================================
    
    /**
     * Schaltet das Protokoll aus
     * WIRKUNG: Spart einen Eintrag in der Datenbank pro Datensatz
     * HINWEIS: Keine Typen in TYPO3 v12. Typen gibt es ab v13.
     */
    public $enableLogging = true;

    /**
     * Umgeht ALLE Prüfungen für Rechte
     * WIRKUNG: Überspringt die Prüfung von Benutzern und Gruppen
     * WARNUNG: Nur in einer sicheren Umgebung nutzen!
     */
    public $bypassAccessCheckForRecords = false;

    /**
     * Überspringt die Prüfung nach dem Speichern
     * WIRKUNG: Entfernt eine Abfrage pro Datensatz
     */
    public $checkStoredRecords = true;

    /**
     * Führt den Code als Administrator aus
     * WIRKUNG: Überspringt das System für Rechte komplett
     * HINWEIS: Setzen Sie dies NACH dem Aufruf von start().
     *       Der Aufruf von start() überschreibt den Wert sonst.
     */
    public $admin;

    // ============================================
    // ARBEITSBEREICH UND VERSIONEN
    // ============================================

    /**
     * Umgeht die Regeln für Arbeitsbereiche
     * WIRKUNG: Überspringt die Logik für Arbeitsbereiche
     * HINWEIS: Versionen werden meistens über das TCA gesteuert.
     *       Dieser Schalter ist dafür nicht so wichtig.
     */
    public $bypassWorkspaceRestrictions = false;

    // ============================================
    // REFERENZINDEX
    // ============================================

    /**
     * HINWEIS: updateRefIndex ist eine Methode. Es ist keine Eigenschaft.
     * Sie können den Referenzindex nicht mit einem Schalter steuern.
     * Sie können das Update verschieben. Nutzen Sie dafür die ReferenceIndex API.
     * Machen Sie das nach dem kompletten Import.
     */
    
    // ============================================
    // GEMERKTER ZUSTAND (Das Problem!)
    // ============================================
    
    /**
     * Protokoll für Fehler. Es wächst bei jeder Aufgabe.
     * PROBLEM: Die Liste wächst bei langen Aufgaben unendlich weiter.
     */
    public array $errorLog = [];
    
    /**
     * Liste für kopierte Einträge.
     * PROBLEM: Der Verbrauch von Speicher steigt immer weiter an.
     */
    public array $copyMappingArray_merged = [];
    
    /**
     * Liste für neue Platzhalter-IDs.
     * PROBLEM: Die Liste wächst mit der Anzahl der neuen Einträge.
     */
    public array $remapStack = [];
}

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

function getOptimizedDataHandler(): DataHandler
{
    $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
    
    // Verbesserungen für die Leistung (vor start() setzen)
    $dataHandler->enableLogging = false;              // -5 bis 10 Prozent Zeit
    $dataHandler->bypassAccessCheckForRecords = true; // -3 bis 5 Prozent Zeit
    $dataHandler->checkStoredRecords = false;         // -2 bis 3 Prozent Zeit

    // HINWEIS: Sie müssen $dataHandler->admin NACH start() setzen.
    // Der Aufruf von start() überschreibt es sonst.
    // Die Methode updateRefIndex() steuert den Referenzindex.
    // Das ist keine Eigenschaft. Sie können das Update verschieben.
    // Nutzen Sie dafür die ReferenceIndex API nach dem Import.

    return $dataHandler;
}

// Versionen für die Dauer des Imports ausschalten
$GLOBALS['TCA']['tx_news_domain_model_news']['ctrl']['versioningWS'] = false;

// Viele Daten importieren...

// Danach wieder einschalten (wenn nötig)
$GLOBALS['TCA']['tx_news_domain_model_news']['ctrl']['versioningWS'] = true;

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

function bulkImportWithOptimization(array $records, string $tableName): void
{
    // Versionen ausschalten
    $GLOBALS['TCA'][$tableName]['ctrl']['versioningWS'] = false;
    
    // Verbindung zur Datenbank für die Transaktion holen
    $connection = GeneralUtility::makeInstance(ConnectionPool::class)
        ->getConnectionForTable($tableName);
    
    // Transaktion starten
    $connection->beginTransaction();
    
    try {
        // Verarbeitung in Paketen von 500 Einträgen
        $chunks = array_chunk($records, 500);
        
        foreach ($chunks as $chunk) {
            // NEUER DataHandler für jedes Paket - sehr wichtig!
            $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
            
            // Verbesserungen anwenden (vor dem Start)
            $dataHandler->enableLogging = false;
            $dataHandler->bypassAccessCheckForRecords = true;
            $dataHandler->checkStoredRecords = false;

            // Daten vorbereiten
            $dataMap = [];
            foreach ($chunk as $record) {
                $dataMap[$tableName]['NEW' . uniqid()] = $record;
            }

            // Ausführen
            $dataHandler->start($dataMap, []);
            // Administrator NACH start() setzen. start() überschreibt es sonst.
            $dataHandler->admin = true;
            $dataHandler->process_datamap();
            
            // Auf Fehler prüfen
            if (!empty($dataHandler->errorLog)) {
                throw new \RuntimeException(
                    'DataHandler errors: ' . implode(', ', $dataHandler->errorLog)
                );
            }
            
            // Arbeitsspeicher leeren
            unset($dataHandler);
        }
        
        // Transaktion abschließen
        $connection->commit();
        
        // Zwischenspeicher einmal am Ende leeren
        $cacheManager = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Cache\CacheManager::class);
        $cacheManager->flushCaches();
        
    } catch (\Exception $e) {
        // Bei Fehlern alles rückgängig machen
        $connection->rollBack();
        throw $e;
    }
}

name: typo3-datahandler-benchmark
type: typo3
docroot: public
php_version: "8.2"
webserver_type: apache-fpm
router_http_port: "8080"
router_https_port: "8443"
database:
  type: mariadb
  version: "10.11"
xdebug_enabled: false
web_environment:
  - TYPO3_CONTEXT=Development
php:
  ini:
    memory_limit: '2G'

<?php
declare(strict_types=1);

namespace App\Command;

use Faker\Factory;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use TYPO3\CMS\Core\Core\Environment;

#[AsCommand(
    name: 'data:generate',
    description: 'Generates fake news records for benchmarking'
)]
class GenerateDataCommand extends Command
{
    protected function configure(): void
    {
        $this->addArgument('count', InputArgument::OPTIONAL, 'Number of records', '10000');
        $this->addArgument('pid', InputArgument::OPTIONAL, 'Target PID', '1');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);
        $count = (int)$input->getArgument('count');
        $pid = (int)$input->getArgument('pid');
        $faker = Factory::create();
        $records = [];

        $io->progressStart($count);

        for ($i = 0; $i < $count; $i++) {
            $records[] = [
                'pid' => $pid,
                'title' => $faker->sentence(),
                'teaser' => $faker->paragraph(),
                'bodytext' => $faker->paragraphs(3, true),
            ];
            $io->progressAdvance();
        }

        $io->progressFinish();

        $filePath = Environment::getProjectPath() . '/var/data/news_records.json';
        file_put_contents($filePath, json_encode($records, JSON_PRETTY_PRINT));

        $io->success(sprintf('%d records generated: %s', $count, $filePath));

        return Command::SUCCESS;
    }
}

<?php
declare(strict_types=1);

namespace App\Command;

use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use TYPO3\CMS\Core\Core\Bootstrap;
use TYPO3\CMS\Core\Core\Environment;
use TYPO3\CMS\Core\DataHandling\DataHandler;
use TYPO3\CMS\Core\Utility\GeneralUtility;

#[AsCommand(
    name: 'data:import',
    description: 'Imports news records with benchmarking'
)]
class ImportDataCommand extends Command
{
    protected function configure(): void
    {
        $this->addOption('batch-size', null, InputOption::VALUE_REQUIRED, 'Records per batch', 0);
        $this->addOption('disable-logging', null, InputOption::VALUE_NONE, 'Disable logging');
        $this->addOption('bypass-permissions', null, InputOption::VALUE_NONE, 'Bypass permissions');
        $this->addOption('disable-versioning', null, InputOption::VALUE_NONE, 'Disable versioning');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);
        $startTime = hrtime(true);

        Bootstrap::initializeBackendAuthentication();

        $filePath = Environment::getProjectPath() . '/var/data/news_records.json';
        if (!file_exists($filePath)) {
            $io->error('Data file not found. Run data:generate first.');
            return Command::FAILURE;
        }

        $records = json_decode(file_get_contents($filePath), true);
        $tableName = 'tx_news_domain_model_news';

        if ($input->getOption('disable-versioning')) {
            $GLOBALS['TCA'][$tableName]['ctrl']['versioningWS'] = false;
        }

        $batchSize = (int)$input->getOption('batch-size');
        if ($batchSize > 0) {
            $this->runBatchedImport($records, $tableName, $batchSize, $input, $io);
        } else {
            $this->runSingleImport($records, $tableName, $input, $io);
        }

        $executionTime = (hrtime(true) - $startTime) / 1e9;
        $peakMemory = memory_get_peak_usage(true) / 1024 / 1024;

        $io->table(
            ['Metric', 'Value'],
            [
                ['Execution Time', sprintf('%.2f seconds', $executionTime)],
                ['Peak Memory', sprintf('%.2f MB', $peakMemory)],
                ['Throughput', sprintf('%.2f rec/s', count($records) / $executionTime)],
            ]
        );

        return Command::SUCCESS;
    }

    private function runBatchedImport(
        array $records,
        string $tableName,
        int $batchSize,
        InputInterface $input,
        SymfonyStyle $io
    ): void {
        $chunks = array_chunk($records, $batchSize);
        $io->progressStart(count($chunks));

        foreach ($chunks as $chunk) {
            $dataMap = [];
            foreach ($chunk as $record) {
                $dataMap[$tableName]['NEW' . uniqid()] = $record;
            }

            $dataHandler = $this->getDataHandlerInstance($input);
            $dataHandler->start($dataMap, []);
            $dataHandler->admin = true; // Must be set after start()
            $dataHandler->process_datamap();

            unset($dataHandler);
            $io->progressAdvance();
        }

        $io->progressFinish();
    }

    private function getDataHandlerInstance(InputInterface $input): DataHandler
    {
        $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
        $dataHandler->checkStoredRecords = false;

        if ($input->getOption('disable-logging')) {
            $dataHandler->enableLogging = false;
        }
        if ($input->getOption('bypass-permissions')) {
            $dataHandler->bypassAccessCheckForRecords = true;
        }
        
        return $dataHandler;
    }
}