Lernseite · Datenbankzugriff und DataHandler

Daten lesen und schreiben in TYPO3

Stand 15. November 2026 · TYPO3 14.3 LTS · ca. 18 Min. Lesezeit

Fast alles in TYPO3 liegt in einer Datenbank. Diese Seite geht von unten nach oben: erst Datenbanken und SQL, dann Doctrine DBAL mit QueryBuilder und Restrictions, zum Schluss DataHandler und Registry. Danach weißt du, welches Werkzeug du wann nimmst und wie du Abfragen sicher baust.

Datenbanken: relational und Key-Value

Ein Datenbankmanagementsystem, kurz DBMS, ist eine Software, die Daten speichert, verwaltet und Abfragen beantwortet.

Relational heißt: Die Daten liegen in Tabellen aus Zeilen und Spalten, die über Schlüssel verknüpft sind. Der Primärschlüssel kennzeichnet jede Zeile eindeutig. Ein Fremdschlüssel zeigt auf den Primärschlüssel einer anderen Tabelle. Transaktionen sorgen nach dem ACID-Prinzip für konsistente Änderungen.

Abgefragt wird mit SQL. Jedes System spricht dabei seinen eigenen Dialekt. TYPO3 14 läuft mit MySQL, MariaDB, PostgreSQL und SQLite. Oracle, Microsoft SQL Server und MongoDB unterstützt TYPO3 nicht.

Ganz anders arbeitet ein Key-Value-Speicher wie Redis oder Memcached. Er legt jeden Wert unter einem eindeutigen Schlüssel ab und liefert ihn über diesen Schlüssel. Es gibt kein festes Schema und keine Abfragen mit JOIN. Dafür ist er sehr schnell, und Einträge können eine Ablaufzeit bekommen. Darum eignet er sich für Caches, Sessions und Konfigurationswerte.

Daten lesen und ändern mit SQL

SELECT liest Zeilen, WHERE schränkt sie ein. ORDER BY sortiert, mit ASC aufsteigend und mit DESC absteigend. GROUP BY fasst Zeilen zu Gruppen zusammen, Funktionen wie COUNT rechnen je Gruppe. HAVING filtert die Gruppen.

SELECT category, COUNT(*) FROM products
WHERE active = 1
GROUP BY category
HAVING COUNT(*) > 5;
SQL-Beispiel. Es zählt je Kategorie die aktiven Produkte und behält nur Kategorien mit mehr als fünf Produkten.

Die Reihenfolge ist fest: SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT. WHERE filtert Zeilen vor dem Gruppieren, HAVING Gruppen danach. Deshalb darf COUNT nicht im WHERE stehen.

COUNT mit Stern zählt alle Zeilen. COUNT mit einem Spaltennamen zählt nur Zeilen, in denen die Spalte nicht NULL ist. Hat die Tabelle der Sprecher zehn Zeilen und bei drei fehlt die E-Mail, ergibt das 10 und 7. Ein leerer Text ist übrigens nicht NULL.

Ein JOIN verbindet Tabellen. Ein INNER JOIN liefert nur passende Paare. Ein LEFT JOIN von Kategorien auf Produkte liefert alle Kategorien, auch ohne Produkte. Die Produktspalten sind dann NULL.

Geschrieben wird mit INSERT, UPDATE und DELETE. INSERT legt eine Zeile an. DELETE entfernt Zeilen, die Tabelle selbst bleibt. UPDATE und DELETE ohne WHERE treffen alle Zeilen, und die Datenbank lehnt das nicht ab.

Struktur, Beziehungen und Tabellen in TYPO3

Befehle für Daten heißen DML. Befehle für die Struktur heißen DDL, etwa CREATE TABLE, ALTER TABLE und CREATE INDEX. Eine Spalte fügst du mit ALTER TABLE und ADD hinzu.

Ein Index beschleunigt Suchen und Sortieren auf seinen Spalten. Er kostet aber Speicher und bremst Schreibzugriffe, also nicht jede Spalte indizieren. Ein Index auf pid und deleted hilft Abfragen, die nach beiden filtern. Das Ergebnis einer Abfrage ändert ein Index nie.

Beziehungen beschreibt man über ihre Kardinalität:

  • Eins zu eins: Eine Person hat genau einen Personalausweis.
  • Eins zu n: Ein Blog hat viele Beiträge, jeder Beitrag gehört zu einem Blog. Der Fremdschlüssel liegt auf der n-Seite. Hält ein Sprecher viele Vorträge, steht seine uid also in der Tabelle der Vorträge.
  • M zu n: Beiträge haben viele Tags, Tags gehören zu vielen Beiträgen. Das braucht eine Zwischentabelle mit Fremdschlüsseln auf beide Seiten.

In TYPO3 heißt die Zwischentabelle MM-Tabelle, mit den Spalten uid_local, uid_foreign und sorting. Eine kommagetrennte Liste in einer Spalte verstößt gegen die erste Normalform, die atomare Werte verlangt. Die Lösung ist auch hier eine MM-Tabelle.

Jede Tabelle, die TYPO3 verwaltet, hat feste Felder:

  • uid ist der eindeutige Primärschlüssel des Datensatzes.
  • pid ist die uid der Seite, auf der er liegt. Der Wert 0 bedeutet die Root-Ebene.
  • tstamp hält die letzte Änderung, crdate die Erstellung.
  • deleted markiert Gelöschtes, hidden Verborgenes.

Produkte oder News ohne eigene Inhaltsseite legst du in einer Seite vom Typ Ordner ab, das ist doktype 254.

Ist in der TCA ctrl.delete gesetzt, setzt das Backend beim Löschen nur das Feld deleted auf 1. Das heißt Soft Delete. Die Zeile bleibt, wird aber überall ausgeblendet, und der Recycler holt sie zurück. Ein verborgener Datensatz bleibt dagegen im Backend sichtbar.

Eigene Tabellen beschreibst du in ext_tables.sql. Die Verwaltungsfelder legt TYPO3 selbst an. In die Datei gehört nur, was abweicht, zum Beispiel ein Index. Der Schemaabgleich im Modul Maintenance oder der Befehl extension:setup überträgt ihn in die Datenbank.

CREATE TABLE tx_myextension_domain_model_talk (
    KEY event_date (event_date)
);
Auszug aus ext_tables.sql. Die Tabelle der Vorträge bekommt einen Index auf der Spalte event_date.

Doctrine DBAL und der QueryBuilder

Die Datenbankschicht von TYPO3 baut auf Doctrine DBAL auf, dem Database Abstraction Layer. Es bietet Verbindungen, QueryBuilder und Schemaverwaltung und übersetzt alles in den Dialekt des Systems. Doctrine ORM bildet Zeilen auf Objekte ab und verwaltet deren Zustand. Es gehört nicht zum Core. Extbase hat ein eigenes ORM auf Basis der TCA.

Der Einstieg ist der ConnectionPool. Er liefert mit getConnectionForTable() eine Verbindung und mit getQueryBuilderForTable() einen QueryBuilder. Die alte Klasse DatabaseConnection gibt es nicht mehr.

Die Connection hat Kurzformen wie insert(), update(), delete() und select(). Sie binden die Werte automatisch als Parameter. Für eine technische Tabelle ohne TCA, etwa ein Import-Protokoll, ist das der übliche Weg. Schreibt ein Import in zwei Tabellen, nutzt du eine Transaktion. Dann gelingen beide Änderungen gemeinsam oder keine.

$connection = $this->connectionPool->getConnectionForTable('tx_myextension_log');
$connection->insert('tx_myextension_log', ['message' => $message, 'crdate' => time()]);

$connection->transactional(function () use ($connection) { /* beide Schreibzugriffe */ });

$connection->beginTransaction();
try {
    /* beide Schreibzugriffe */
    $connection->commit();
} catch (\Throwable $e) {
    $connection->rollBack();
    throw $e;
}
Codebeispiel. Die Connection schreibt mit insert ins Protokoll. Darunter zwei Wege zur Transaktion: transactional rollt bei einer Exception selbst zurück, der manuelle Weg nutzt commit und rollBack.

Für alles andere nimmst du den QueryBuilder. Er hat eine Methode je Klausel, Bedingungen baut der ExpressionBuilder hinter expr(). Hol für jede Abfrage einen neuen QueryBuilder vom ConnectionPool, denn er merkt sich seinen Zustand.

$qb = $this->connectionPool->getQueryBuilderForTable('tx_myextension_domain_model_talk');
$rows = $qb
    ->select('t.uid', 't.title')
    ->from('tx_myextension_domain_model_talk', 't')
    ->join('t', 'tx_myextension_domain_model_conference', 'c',
        $qb->expr()->eq('c.uid', $qb->quoteIdentifier('t.conference')))
    ->where($qb->expr()->like('t.title',
        $qb->createNamedParameter('%' . $qb->escapeLikeWildcards($term) . '%')))
    ->executeQuery()
    ->fetchAllAssociative();
Codebeispiel für die Vortragssuche. Ein Join verbindet Vortrag und Konferenz. Weil dort zwei Feldnamen verglichen werden, steht das zweite Feld in quoteIdentifier. Der Suchbegriff geht mit escapeLikeWildcards und createNamedParameter in die LIKE-Bedingung. executeQuery und fetchAllAssociative liefern die Zeilen als Liste von Arrays.

Ausführen geht auf zwei Arten:

  • executeQuery() ist für SELECT und COUNT und liefert ein Result. Daraus liest fetchAllAssociative() alle Zeilen, fetchAssociative() die nächste und fetchOne() einen einzelnen Wert. Gibt es keine Zeile, liefert fetchAssociative() den Wert false.
  • executeStatement() ist für INSERT, UPDATE und DELETE und liefert die Zahl der betroffenen Zeilen.

Zählen soll die Datenbank. Die Methode count() ersetzt den SELECT-Teil durch COUNT, und fetchOne() liest die Zahl. Alle Zeilen zu laden und in PHP zu zählen kostet Speicher und Zeit.

$count = $qb->count('uid')
    ->from('tx_myextension_domain_model_talk')
    ->where($qb->expr()->eq('pid', $qb->createNamedParameter(12, Connection::PARAM_INT)))
    ->executeQuery()
    ->fetchOne();

$qb->expr()->in('uid', $qb->createNamedParameter($uids, Connection::PARAM_INT_ARRAY));
Codebeispiel. count auf uid mit der Bedingung pid gleich 12, danach fetchOne. Darunter eine IN-Bedingung, deren Liste als Parameter vom Typ PARAM_INT_ARRAY übergeben wird.

Eine Liste braucht einen Array-Typ. PARAM_INT_ARRAY ist die TYPO3-Konstante für ArrayParameterType::INTEGER aus Doctrine, beide sind gleichwertig. Für Texte gibt es PARAM_STR_ARRAY.

Anders als der QueryBuilder von Doctrine hängt der von TYPO3 bei SELECT und COUNT automatisch Restrictions an und quotet Namen.

Restrictions: was automatisch ausgeblendet wird

Eine Abfrage auf tt_content liefert ohne dein Zutun keine gelöschten und keine verborgenen Datensätze. Der Grund sind Restrictions: Bedingungen, die der QueryBuilder aus der TCA ergänzt. Sie gelten in Frontend, Backend und auf der Kommandozeile.

DefaultRestrictionContainer immer aktiv: Frontend, Backend, Kommandozeile DeletedRestriction HiddenRestriction StartTimeRestriction EndTimeRestriction FrontendRestrictionContainer selbst setzen: so lesen wie ein Besucher DeletedRestriction HiddenRestriction StartTimeRestriction EndTimeRestriction WorkspaceRestriction FrontendGroupRestriction removeAll() entfernt alles außer erzwungenen removeByType() entfernt genau eine, auch erzwungen
Der Standard für jede Abfrage und der Container für den Blick eines Besuchers.

Der DefaultRestrictionContainer ist immer aktiv. Er enthält die DeletedRestriction, HiddenRestriction, StartTimeRestriction und EndTimeRestriction. Benutzergruppen und Workspaces prüft er nicht.

Der FrontendRestrictionContainer ergänzt die WorkspaceRestriction und die FrontendGroupRestriction. Du setzt ihn selbst, wenn zum Beispiel ein Konsolenbefehl lesen soll wie ein nicht angemeldeter Besucher.

Anpassen kannst du sie über getRestrictions():

  • removeByType() entfernt genau eine. Soll ein Backend-Modul auch Verborgenes zeigen, entfernst du die HiddenRestriction. Gelöschtes bleibt ausgeblendet.
  • removeAll() entfernt alle, auch die für Gelöschtes.
  • add() fügt eine hinzu. Alles außer Gelöschtem siehst du mit removeAll() und danach add() mit der DeletedRestriction.
$qb->getRestrictions()->removeByType(HiddenRestriction::class);

$qb->getRestrictions()->removeAll()
    ->add(GeneralUtility::makeInstance(DeletedRestriction::class));

$qb->setRestrictions(GeneralUtility::makeInstance(FrontendRestrictionContainer::class));
Codebeispiel. Zuerst wird nur die HiddenRestriction entfernt. Dann werden alle entfernt und die DeletedRestriction wieder hinzugefügt. Zuletzt wird der FrontendRestrictionContainer gesetzt.

Eine erzwungene Restriction implementiert das EnforceableQueryRestrictionInterface. Sie übersteht removeAll(), aber removeByType() entfernt sie trotzdem. Auch die Kurzformen select() und count() der Connection nutzen die Standard-Restrictions. Anpassen kannst du sie dort aber nicht.

Sicher abfragen

Bei einer SQL-Injection wird eine Eingabe so in eine Abfrage eingebaut, dass sie deren Bedeutung verändert. Das passiert, wenn du einen Wert aus der Anfrage direkt in den SQL-Text klebst. Ein Angreifer schickt dann statt eines Titels ein Stück SQL und liest oder löscht fremde Daten.

$qb->where('title = "' . $request->getQueryParams()['title'] . '"'); // unsicher
$qb->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid, Connection::PARAM_INT))); // sicher
Zwei Codezeilen. Die erste ist unsicher, sie klebt den Titel aus der URL direkt in den SQL-Text. Die zweite ist sicher, der Wert geht über createNamedParameter mit dem Typ PARAM_INT in die Bedingung.

Die Abwehr heißt Prepared Statement. Die Datenbank bekommt zuerst die Abfrage mit Platzhaltern und danach getrennt die Werte. Ein Wert kann so nie als Befehl gelesen werden. Läuft dieselbe Abfrage oft, kann das sogar schneller sein, weil die Datenbank sie nur einmal analysiert.

Im QueryBuilder geht darum jede Eingabe durch createNamedParameter(). Mit PARAM_INT geht der Wert als Zahl an die Datenbank, nicht als Text. Auch eigenes SQL mit executeStatement() braucht Parameter. Die Kurzformen der Connection, Extbase-Abfragen über das Query-Objekt und der DataHandler binden ihre Werte selbst.

Prepared Statements haben Grenzen:

  • Tabellen- und Spaltennamen lassen sich nicht als Platzhalter übergeben. Für Feldnamen gibt es quoteIdentifier(), für Werte ist es falsch.
  • Prozentzeichen und Unterstrich bleiben bei LIKE Platzhalter. Die maskierst du mit escapeLikeWildcards(). Die eigenen Prozentzeichen außen herum brauchst du trotzdem, sonst gibt es nur genaue Treffer.
  • Vor Cross-Site-Scripting bei der Ausgabe schützen sie nicht.

Den Schaden begrenzt du außerdem so: Gib dem Datenbankbenutzer nur die nötigen Rechte. Zeig Besuchern keine Fehlermeldungen der Datenbank, denn sie verraten die Struktur. Eigenes Escaping, etwa Anführungszeichen mit str_replace entfernen, ist fehleranfällig.

Persistenz im Core

TYPO3 schreibt Datensätze auf zwei Wegen. Im Backend speichert der DataHandler. Plugins und Extbase-Module nutzen die Extbase-Persistenz. Sie schreibt am DataHandler vorbei über Doctrine DBAL, liest aber die TCA für die Zuordnung.

Die TCA beschreibt jede Tabelle mit Feldern, Typen und Relationen. Statt das rohe Array zu lesen, nutzt du die Schema API: Die TcaSchemaFactory liefert mit get() ein Schema-Objekt mit den Feldern und Fähigkeiten einer Tabelle.

Der Referenzindex in sys_refindex speichert Verweise zwischen Datensätzen und Dateien. Daraus zeigt das Backend, wo etwas verwendet wird. Der DataHandler hält ihn aktuell, seit TYPO3 14 auch Extbase. Ein direkter SQL-Import umgeht das, danach stimmt die Anzeige nicht. Dann hilft der Befehl referenceindex:update oder seit TYPO3 14 das Modul Maintenance mit Check and Update Reference Index.

AUFGABE WERKZEUG Redakteursdaten ändern mit Rechten und Historie DataHandler Fachlogik in Plugins und Extbase-Modulen Repository Listen, Suchen, Statistiken viele Zeilen lesen QueryBuilder Technische Tabellen ohne TCA schreiben Connection Einzelne Werte für die ganze Installation Registry
Welches Werkzeug für welche Aufgabe.

Der DataHandler

Der DataHandler legt Datensätze so an, ändert und löscht sie, wie es das Backend tut. Er prüft die Rechte des Backend-Benutzers und wendet die TCA an. Er schreibt Historie und Protokoll, pflegt den Referenzindex und leert Caches. Felder ohne TCA verarbeitet er nicht.

datamap Feldwerte je Tabelle und uid NEW1 für neue Datensätze cmdmap Befehle je Tabelle und uid copy, move, delete, discard DataHandler Backend-Benutzer und Rechte prüfen TCA-Regeln anwenden schreibt und pflegt Datensätze Historie und Protokoll Referenzindex Caches leeren substNEWwithIDs neue uids je Platzhalter errorLog Fehler, keine Exception
Zwei Arrays hinein, alles wie beim Speichern im Backend.

Die datamap enthält Feldwerte, geordnet nach Tabelle, uid und Feld. Ein neuer Datensatz bekommt statt einer uid einen Platzhalter, der mit NEW beginnt, etwa NEW1. Ohne Unterstrich, denn in Relationsfeldern liest TYPO3 einen Unterstrich als Trenner zwischen Tabelle und Nummer. Die pid gibt die Seite an, auf der der Datensatz entsteht.

$data['tx_myextension_domain_model_talk']['NEW1'] = ['pid' => 12, 'title' => 'Neu'];

$dataHandler = GeneralUtility::makeInstance(DataHandler::class);
$dataHandler->start($data, []);
$dataHandler->process_datamap();
if ($dataHandler->errorLog !== []) { /* Fehler protokollieren */ }
$newUid = $dataHandler->substNEWwithIDs['NEW1'];
Codebeispiel aus dem Import. Die datamap legt den Platzhalter NEW1 mit pid 12 an. Ein frischer DataHandler startet mit der datamap und führt process_datamap aus. Danach wird errorLog geprüft, und substNEWwithIDs liefert die neue uid.

Die Methode process_datamap() gibt nichts zurück. Fehler sammelt der DataHandler in errorLog, auch fehlende Rechte. Die neuen uids stehen in substNEWwithIDs.

Die cmdmap enthält Befehle, geordnet nach Tabelle, uid und Befehl, und läuft mit process_cmdmap(). Befehle sind etwa copy, move, delete und localize. Neu in TYPO3 14 ist discard. Er verwirft Workspace-Änderungen, ersetzt die alten Aktionen clearWSID und flush und erwartet die uid der Workspace-Version. Beim Kopieren ist ein positiver Wert eine Zielseite. Ein negativer Wert ist ein Datensatz derselben Tabelle, hinter dem eingefügt wird.

$cmd['tx_myextension_domain_model_talk'][5]['delete'] = 1;
$cmd['tt_content'][1203]['copy'] = -303;
$cmd['pages'][$workspaceVersionUid]['discard'] = true;

$dataHandler->start([], $cmd);
$dataHandler->process_cmdmap();
Drei Befehle. Der erste löscht den Vortrag 5 wie ein Redakteur. Der zweite kopiert Inhaltselement 1203 auf die Seite von Element 303, direkt dahinter. Der dritte verwirft eine Workspace-Version. Dann folgen start mit leerer datamap und process_cmdmap.

Setz das Feld deleted nicht selbst über die datamap. Das umgeht Rechte, Historie und Referenzindex.

In eigenem Code gilt:

  • Hol jedes Mal einen neuen DataHandler mit makeInstance, denn er hält Zustand.
  • Er prüft die Rechte des Backend-Benutzers, auch wenn du ihn aus PHP aufrufst. In einem Konsolenbefehl rufst du deshalb vor start() die Methode initializeBackendAuthentication() der Klasse Bootstrap auf. Dann arbeitet er als Administrator _cli_.
  • Er ist langsamer als direktes SQL, dafür stimmen Sortierung, Referenzindex und Historie. Große Importe verarbeitest du in Paketen.

Eigene Logik beim Speichern hängst du per Hook ein. Die Klasse registrierst du in ext_localconf.php unter processDatamapClass oder processCmdmapClass.

$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tcemain.php']['processDatamapClass'][]
    = \MyVendor\MyExtension\Hooks\TalkHook::class;
Registrierung eines Hooks. Die Klasse TalkHook wird unter SC_OPTIONS, im alten Schlüssel für die Datei class.t3lib_tcemain.php, bei processDatamapClass eingetragen.

Die Methode processDatamap_preProcessFieldArray() bekommt die eingehenden Werte als Referenz, bevor der DataHandler sie prüft und speichert. processDatamap_afterDatabaseOperations() läuft erst nach dem Schreiben. Hooks greifen nur, wenn über den DataHandler geschrieben wird.

Die System-Registry

Die Registry ist ein kleiner Key-Value-Speicher in der Tabelle sys_registry. Sie speichert Werte dauerhaft unter einem Namespace und einem Schlüssel. Beim Leeren der Caches bleiben sie erhalten.

$this->registry->set('tx_myextension', 'lastImport', time());
$lastImport = $this->registry->get('tx_myextension', 'lastImport', 0);
Codebeispiel. set speichert im Namespace tx_myextension unter lastImport die aktuelle Zeit. get liest den Wert und liefert 0, falls noch nichts gespeichert ist.

Der dritte Wert von get() ist der Standardwert. Als Namespace nimmt man den Extension-Key mit dem Präfix tx_. Er muss mindestens zwei Zeichen lang sein, und core ist für den Core reserviert.

Die Registry passt für kleine technische Zustände wie den letzten Import. Sie passt nicht für Einstellungen, die Redakteure pflegen. Die gehören in Datensätze mit TCA oder in Site-Settings. Zwischengespeichertes gehört in einen Cache, große Datenmengen ins Dateisystem.

Das Wichtigste in Kürze

  • TYPO3 14 läuft mit MySQL, MariaDB, PostgreSQL und SQLite, über Doctrine DBAL und nicht über Doctrine ORM.
  • WHERE filtert vor dem Gruppieren, HAVING danach. UPDATE und DELETE ohne WHERE treffen alle Zeilen.
  • Bei eins zu n liegt der Fremdschlüssel auf der n-Seite, m zu n braucht eine MM-Tabelle.
  • Den QueryBuilder holst du je Abfrage neu. Lesen mit executeQuery(), schreiben mit executeStatement().
  • Der DefaultRestrictionContainer blendet Gelöschtes, Verborgenes und Zeitgesteuertes aus.
  • Jede Eingabe geht durch createNamedParameter(), Spaltennamen nur über eine feste Liste.
  • Der DataHandler braucht einen Backend-Benutzer. Fehler stehen in errorLog, neue uids in substNEWwithIDs.

Begriffe

DBAL
Database Abstraction Layer, vereinheitlicht den Zugriff auf verschiedene Datenbanksysteme.
datamap
Datenarray des DataHandlers mit Feldwerten je Tabelle und uid.
cmdmap
Befehlsarray des DataHandlers, etwa zum Kopieren, Löschen oder Verwerfen.
MM-Tabelle
Zwischentabelle für eine Beziehung m zu n.
Prepared Statement
Abfrage mit Platzhaltern, deren Werte getrennt übertragen werden.
Referenzindex
Tabelle sys_refindex mit allen Verweisen zwischen Datensätzen und Dateien.
Restriction
Bedingung, die der QueryBuilder automatisch an eine Abfrage hängt.
Soft Delete
Löschen durch Setzen des Felds deleted statt Entfernen der Zeile.

Stand: 15. November 2026 (TYPO3 14.3 LTS)

Quellen:

  • TYPO3 Explained 14.3, Kapitel Database (Doctrine DBAL, QueryBuilder, Restrictions, Connection)
  • TYPO3 Explained 14.3, Kapitel DataHandler, Reference Index und System Registry
  • Changelog TYPO3 14 (discard-Befehl, Referenzindex, QueryBuilderPaginator)
  • Quellcode TYPO3 14.3 (typo3/cms-core), geprüft für Restrictions, Connection, Registry und DataHandler
  • Lernzielkatalog TYPO3 CMS Certified Developer 14 LTS, Bereich Datenbankzugriff

Diese Lernseite ist mit KI erstellt und gegen die Quellen geprüft.

Zertifikate & Prüfungen

Welche Prüfung kommt als Nächstes?

51 Prüfungen kannst du schon üben, über 16 stimmst du gerade ab. Sieh dir alle Zertifikate mit offiziellen Infos an, gib deine Stimme ab oder schlag deine Prüfung vor.

Zur Zertifikatsübersicht