Was ist der TYPO3 Query­Buil­der?

Mit dem TYPO3 Query­Buil­der können Sie in­di­vi­du­el­le Da­ten­bank­ab­fra­gen erstellen, ohne hierfür SQL-Code schreiben zu müssen. Dabei eignet sich der Query­Buil­der sowohl für einfache als auch komplexe Abfragen und stellt eine prak­ti­sche Lösung für die Arbeit mit TYPO3-Da­ten­ban­ken dar.

Wozu dient der TYPO3 Query­Buil­der?

Der Haupt­zweck des TYPO3 Query­Buil­ders ist es, komplexe Da­ten­ab­fra­gen zu ver­ein­fa­chen. Er bietet eine struk­tu­rier­te Mög­lich­keit, mit TYPO3-Da­ten­ban­ken zu in­ter­agie­ren. Der Query­Buil­der dient dy­na­mi­schen und an­pass­ba­ren Abfragen, bei denen die Da­ten­quel­le, Filter und Ab­fra­ge­be­din­gun­gen leicht verändert werden können.

Ein zentrales Merkmal des Query­Buil­ders ist seine Fle­xi­bi­li­tät bei der Er­stel­lung von Abfragen. Er kann zum Beispiel für einfache Aufgaben wie das Abrufen von Daten oder für WHERE-Be­din­gun­gen genutzt werden. An­spruchs­vol­le­re Ope­ra­tio­nen wie Ver­knüp­fun­gen zwischen mehreren Tabellen oder das dy­na­mi­sche Erstellen von Abfragen basierend auf Be­nut­zer­ein­ga­ben sind ebenso möglich.

Wann lohnt sich die Nutzung des Query­Buil­ders?

Der TYPO3 Query­Buil­der eignet sich besonders gut, wenn folgende Be­din­gun­gen oder Er­war­tun­gen erfüllt sind:

Komplexe Da­ten­bank­ab­fra­gen ohne Mo­dell­de­fi­ni­ti­on

In TYPO3 ist es üblich, für die meisten Tabellen Modelle zu erstellen, um auf die Daten zu­zu­grei­fen und diese zu ma­ni­pu­lie­ren. Doch in manchen Fällen ist es nicht notwendig, für jede Tabelle ein voll­stän­di­ges Model zu de­fi­nie­ren. Der Einsatz des Query­Buil­ders ist sinnvoll, wenn Sie mit Tabellen ohne Da­ten­mo­dell arbeiten müssen oder wenn das Erstellen eines Modells für bestimmte An­wen­dungs­fäl­le zu aufwendig oder unnötig erscheint. In diesen Fällen können Sie mit dem Query­Buil­der trotzdem komplexe Abfragen auf einfache und effektive Weise durch­füh­ren. Über ver­schie­de­ne Join-Methoden können Sie zudem schnell und effizient Tabellen mit­ein­an­der ver­knüp­fen und die be­nö­tig­ten Daten ex­tra­hie­ren.

Dy­na­mi­sche und an­pass­ba­re An­for­de­run­gen

In vielen Projekten ändern sich die An­for­de­run­gen an die Da­ten­ab­fra­gen während der Ent­wick­lungs­pha­se oder im Betrieb. Der Query­Buil­der er­leich­tert die Er­stel­lung flexibler, dy­na­mi­scher Abfragen, die sich schnell und un­kom­pli­ziert anpassen lassen – sei es für die Er­wei­te­rung be­stehen­der Funk­tio­na­li­tä­ten oder für die Im­ple­men­tie­rung neuer An­for­de­run­gen.

Feh­ler­re­du­zie­rung und Si­cher­heits­aspek­te

Da­ten­bank­ab­fra­gen, ins­be­son­de­re wenn sie Be­nut­zer­ein­ga­ben ein­be­zie­hen, bergen immer das Risiko von Fehlern und Si­cher­heits­lü­cken. Der Query­Buil­der übernimmt viele der si­cher­heits­re­le­van­ten Aufgaben, die in SQL-Abfragen manuell erledigt werden müssten, wie zum Beispiel das Escapen von Ein­ga­be­wer­ten und den Schutz vor SQL-Injection.

Code­bei­spie­le für die Nutzung des TYPO3 Query­Buil­ders

Um mit dem Query­Buil­der in TYPO3 zu arbeiten, sind mehrere Schritte notwendig. Zunächst müssen Sie die er­for­der­li­chen Name­spaces im­por­tie­ren und dann den Query­Buil­der in­stan­zi­ie­ren, um Abfragen durch­zu­füh­ren.

In­stan­zi­ie­rung des Query­Buil­ders

Bevor wir den Query­Buil­der verwenden können, müssen wir eine Instanz der Klasse ConnectionPool erstellen und den Query­Buil­der für eine bestimmte Tabelle abrufen. Der ConnectionPool sorgt dafür, dass wir eine Ver­bin­dung zur Datenbank her­stel­len können und den Query­Buil­der für eine Tabelle erhalten.

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Database\ConnectionPool;
$queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('table_content');

Mit dieser In­stan­zi­ie­rung erhalten wir einen TYPO3 Query­Buil­der für die Tabelle table_content. Der Name kann frei gewählt werden. Nun können wir damit ver­schie­de­ne Da­ten­bank­ab­fra­gen ausführen.

SELECT-Abfrage

Nehmen wir an, wir möchten Inhalte aus der Tabelle table_content abfragen und nur bestimmte Felder wie uid (ID) und ctype (Content-Type) auswählen. Dies wird fol­gen­der­ma­ßen durch­ge­führt:

$queryBuilder
    ->select('*') 
    ->from('table_content')    
    ->where(
        $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter(123, \PDO::PARAM_INT)) 
    )

In diesem Beispiel suchen wir nach allen Zeilen in der table_content-Tabelle, bei denen die uid gleich 123 ist.

ODER-Ver­knüp­fung mit orWhere()

Es kann er­for­der­lich sein, mehrere Be­din­gun­gen zu kom­bi­nie­ren, wobei eine der Be­din­gun­gen durch orWhere() verbunden wird. Hier ein Beispiel:

$queryBuilder
    ->select('*') 
    ->from('table_content')
    ->where(
        $queryBuilder->expr()->eq('pid', $queryBuilder->createNamedParameter(42, \PDO::PARAM_INT)) 
    )
    ->orWhere(
        $queryBuilder->expr()->like('header', $queryBuilder->createNamedParameter('%' . $queryBuilder->escapeLikeWildcards('Special') . '%', \PDO::PARAM_STR)) 
    )

Wir haben die WHERE-Bedingung mit orWhere() kom­bi­niert, um entweder nach einer be­stimm­ten pid zu filtern oder den header nach einem spe­zi­el­len Begriff zu durch­su­chen.

INNER JOIN

Ein INNER JOIN wird verwendet, um Daten aus mehreren Tabellen zu verbinden. Hier ver­knüp­fen wir die Tabellen table_content und pages, basierend auf der pid und der uid von pages:

$queryBuilder
    ->select('*') 
    ->from('table_content')
    ->innerJoin(
        'table_content', 'pages', 'pages', 
        $queryBuilder->expr()->eq('table_content.pid', $queryBuilder->quoteIdentifier('pages.uid'))
    )
    ->where(
        $queryBuilder->expr()->eq('pages.uid', $queryBuilder->createNamedParameter(1, \PDO::PARAM_INT)) 
    )

LEFT JOIN

LEFT JOIN wird ein­ge­setzt, wenn wir alle Zeilen aus der linken Tabelle und die passenden Zeilen aus der rechten Tabelle zu­rück­ge­ben möchten, auch wenn keine Über­ein­stim­mung in der rechten Tabelle vorhanden ist.

$queryBuilder
    ->select('table_content.uid', 'table_content.header', 'pages.title')
    ->from('table_content')
    ->leftJoin(
        'table_content', 'pages', 'pages', 
        $queryBuilder->expr()->eq('table_content.pid', $queryBuilder->quoteIdentifier('pages.uid'))
    )
    ->where(
        $queryBuilder->expr()->eq('table_content.uid', $queryBuilder->createNamedParameter(1, \PDO::PARAM_INT))
    )

UPDATE-Abfrage

Mit dem TYPO3 Query­Buil­der können wir auch UPDATE-Abfragen durch­füh­ren. Hier ak­tua­li­sie­ren wir den header in der table_content-Tabelle, wenn die uid gleich einer be­stimm­ten Zahl ist:

$queryBuilder
    ->update('table_content')
    ->where(
        $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter(42, \PDO::PARAM_INT))
    )
    ->set('header', $queryBuilder->createNamedParameter('New Header', \PDO::PARAM_STR))
    ->executeStatement();

In diesem Beispiel setzen wir den header auf New Header für den Datensatz mit der uid gleich 42.

DELETE

Mit dem TYPO3 Query­Buil­der kann auch eine DELETE-Abfrage aus­ge­führt werden. In dem folgenden Code löschen wir alle Einträge aus der table_content-Tabelle, deren pid gleich 11 ist:

$queryBuilder
    ->delete('table_content')
    ->where(
        $queryBuilder->expr()->eq('pid', $queryBuilder->createNamedParameter(11, \PDO::PARAM_INT))
    )
    ->executeStatement();