Leistungsanalyse vom TYPO3 DataHandler: Große Datenmengen schneller speichern

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

class DataHandler
{
    // ============================================
    // EIGENSCHAFTEN FÜR LEISTUNG
    // ============================================
    
    /**
     * Logging komplett abschalten
     * WIRKUNG: Spart einen Eintrag in die Datenbank pro Datensatz
     */
    public bool $enableLogging = true;
    
    /**
     * Rechteprüfung komplett überspringen
     * WIRKUNG: Spart viel Zeit
     * ACHTUNG: Nur in sicheren Umgebungen nutzen!
     */
    public bool $bypassAccessCheckForRecords = false;
    
    /**
     * Prüfung nach dem Speichern abschalten
     * WIRKUNG: Spart eine Suche in der Datenbank pro Datensatz
     */
    public bool $checkStoredRecords = true;
    
    /**
     * Als Administrator arbeiten
     * WIRKUNG: Umgeht alle normalen Beschränkungen
     */
    public bool $admin = false;
    
    // ============================================
    // VERSIONEN
    // ============================================
    
    /**
     * Versionierung einschalten
     * WIRKUNG: Speichert Kopien anstatt direkt zu ändern
     */
    public bool $enableWorkspaces = true;
    
    // ============================================
    // REFERENCE INDEX
    // ============================================
    
    /**
     * Reference Index (Verbindungen) aktualisieren
     * WIRKUNG: Macht sehr viele Datenbankabfragen pro Datensatz
     */
    public bool $updateRefIndex = true;
    
    // ============================================
    // DAS PROBLEM MIT DEM ZUSTAND
    // ============================================
    
    /**
     * Fehlerliste
     * PROBLEM: Liste wächst mit jeder Aufgabe
     */
    public array $errorLog = [];
    
    /**
     * Liste von Kopien
     * PROBLEM: Liste verbraucht immer mehr Arbeitsspeicher
     */
    public array $copyMappingArray_merged = [];
    
    /**
     * Liste für neue IDs
     * PROBLEM: 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);
    
    // Leistung verbessern
    $dataHandler->enableLogging = false;              // Spart 5 bis 10 Prozent Zeit
    $dataHandler->bypassAccessCheckForRecords = true; // Spart 3 bis 5 Prozent Zeit
    $dataHandler->checkStoredRecords = false;         // Spart 2 bis 3 Prozent Zeit
    $dataHandler->admin = true;                       // Umgeht Einschränkungen
    
    // Freiwillig: Reference Index abschalten (Bitte sehr vorsichtig nutzen!)
    // $dataHandler->updateRefIndex = false;
    
    return $dataHandler;
}

// Schalten Sie Versionen für die Dauer vom Import ab
$GLOBALS['TCA']['tx_news_domain_model_news']['ctrl']['versioningWS'] = false;

// Machen Sie jetzt den Import...

// Schalten Sie Versionen danach wieder ein
$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 abschalten
    $GLOBALS['TCA'][$tableName]['ctrl']['versioningWS'] = false;
    
    // Verbindung zur Datenbank holen
    $connection = GeneralUtility::makeInstance(ConnectionPool::class)
        ->getConnectionForTable($tableName);
    
    // Transaktion beginnen
    $connection->beginTransaction();
    
    try {
        // Daten in Gruppen von 500 Stück verarbeiten
        $chunks = array_chunk($records, 500);
        
        foreach ($chunks as $chunk) {
            // Sehr wichtig: Einen neuen DataHandler für jede Gruppe starten
            $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
            
            // Verbesserungen einstellen
            $dataHandler->enableLogging = false;
            $dataHandler->bypassAccessCheckForRecords = true;
            $dataHandler->checkStoredRecords = false;
            $dataHandler->admin = true;
            
            // Liste für Daten bauen
            $dataMap = [];
            foreach ($chunk as $record) {
                $dataMap[$tableName]['NEW' . uniqid()] = $record;
            }
            
            // Import starten
            $dataHandler->start($dataMap, []);
            $dataHandler->process_datamap();
            
            // Auf Fehler prüfen
            if (!empty($dataHandler->errorLog)) {
                throw new \RuntimeException(
                    'Fehler im DataHandler: ' . implode(', ', $dataHandler->errorLog)
                );
            }
            
            // Arbeitsspeicher sofort leeren
            unset($dataHandler);
        }
        
        // Alle Daten sicher speichern
        $connection->commit();
        
        // Den Cache ganz am Ende leeren
        $cacheManager = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Cache\CacheManager::class);
        $cacheManager->flushCaches();
        
    } catch (\Exception $e) {
        // Bei Fehlern alle Änderungen zurücknehmen
        $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, 'Anzahl der Einträge', '10000');
        $this->addArgument('pid', InputArgument::OPTIONAL, 'Ziel Ordner (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 Einträge wurden erzeugt: %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, 'Einträge pro Gruppe', 0);
        $this->addOption('disable-logging', null, InputOption::VALUE_NONE, 'Logging abschalten');
        $this->addOption('bypass-permissions', null, InputOption::VALUE_NONE, 'Rechte umgehen');
        $this->addOption('disable-versioning', null, InputOption::VALUE_NONE, 'Versionen abschalten');
    }

    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('Die Datei fehlt. Bitte starten Sie data:generate zuerst.');
            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(
            ['Messwert', 'Wert'],
            [
                ['Laufzeit', sprintf('%.2f Sekunden', $executionTime)],
                ['Höchster Arbeitsspeicher', sprintf('%.2f MB', $peakMemory)],
                ['Durchsatz', sprintf('%.2f Einträge/Sekunde', 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->process_datamap();
            
            unset($dataHandler);
            $io->progressAdvance();
        }
        
        $io->progressFinish();
    }

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

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