# Was ist der TYPO3 QueryBuilder?

Mit dem TYPO3 QueryBuilder können Sie individuelle Datenbankabfragen erstellen, ohne hierfür SQL-Code schreiben zu müssen. Dabei eignet sich der QueryBuilder sowohl für einfache als auch komplexe Abfragen und stellt eine praktische Lösung für die Arbeit mit TYPO3-Datenbanken dar.

## Wozu dient der TYPO3 QueryBuilder?

Der Hauptzweck des TYPO3 QueryBuilders ist es, komplexe Datenabfragen zu vereinfachen. Er bietet eine strukturierte Möglichkeit, **mit TYPO3-Datenbanken zu interagieren**. Der QueryBuilder dient dynamischen und anpassbaren Abfragen, bei denen die Datenquelle, Filter und Abfragebedingungen leicht verändert werden können.

Ein zentrales Merkmal des QueryBuilders ist seine Flexibilität bei der Erstellung von Abfragen. Er kann zum Beispiel für einfache Aufgaben wie das Abrufen von Daten oder für `WHERE`-Bedingungen genutzt werden. Anspruchsvollere Operationen wie Verknüpfungen zwischen mehreren Tabellen oder das dynamische Erstellen von Abfragen basierend auf Benutzereingaben sind ebenso möglich.

## Wann lohnt sich die Nutzung des QueryBuilders?

Der TYPO3 QueryBuilder eignet sich besonders gut, wenn folgende Bedingungen oder Erwartungen erfüllt sind:

### Komplexe Datenbankabfragen ohne Modelldefinition

In TYPO3 ist es üblich, für die meisten Tabellen Modelle zu erstellen, um auf die Daten zuzugreifen und diese zu manipulieren. Doch in manchen Fällen ist es nicht notwendig, für jede Tabelle ein vollständiges Model zu definieren. Der Einsatz des QueryBuilders ist sinnvoll, wenn Sie mit **Tabellen ohne Datenmodell** arbeiten müssen oder wenn das Erstellen eines Modells für bestimmte Anwendungsfälle zu aufwendig oder unnötig erscheint. In diesen Fällen können Sie mit dem QueryBuilder trotzdem komplexe Abfragen auf einfache und effektive Weise durchführen. Über verschiedene `Join`-Methoden können Sie zudem **schnell und effizient Tabellen miteinander verknüpfen** und die benötigten Daten extrahieren.

### Dynamische und anpassbare Anforderungen

In vielen Projekten ändern sich die Anforderungen an die Datenabfragen während der Entwicklungsphase oder im Betrieb. Der QueryBuilder erleichtert die Erstellung flexibler, dynamischer Abfragen, die sich schnell und unkompliziert anpassen lassen – sei es für die Erweiterung bestehender Funktionalitäten oder für die Implementierung neuer Anforderungen.

### Fehlerreduzierung und Sicherheitsaspekte

Datenbankabfragen, insbesondere wenn sie Benutzereingaben einbeziehen, bergen immer das Risiko von Fehlern und Sicherheitslücken. Der QueryBuilder übernimmt viele der sicherheitsrelevanten Aufgaben, die in SQL-Abfragen manuell erledigt werden müssten, wie zum Beispiel das Escapen von Eingabewerten und den Schutz vor [SQL-Injection](https://www.ionos.at/digitalguide/server/sicherheit/sql-injection-grundlagen-und-schutzmassnahmen/).

## Codebeispiele für die Nutzung des TYPO3 QueryBuilders

Um mit dem QueryBuilder in TYPO3 zu arbeiten, sind mehrere Schritte notwendig. Zunächst müssen Sie die erforderlichen **Namespaces importieren** und dann den QueryBuilder instanziieren, um Abfragen durchzuführen.

### Instanziierung des QueryBuilders

Bevor wir den QueryBuilder verwenden können, müssen wir eine Instanz der Klasse `ConnectionPool` erstellen und den QueryBuilder für eine bestimmte Tabelle abrufen. Der `ConnectionPool` sorgt dafür, dass wir eine Verbindung zur Datenbank herstellen können und den QueryBuilder für eine Tabelle erhalten.

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

Mit dieser Instanziierung erhalten wir einen TYPO3 QueryBuilder für die Tabelle `table_content`. Der Name kann frei gewählt werden. Nun können wir damit verschiedene Datenbankabfragen 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 folgendermaßen durchgeführt:

```php
$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`-Verknüpfung mit `orWhere()`

Es kann erforderlich sein, mehrere Bedingungen zu kombinieren, wobei eine der Bedingungen durch `orWhere()` verbunden wird. Hier ein Beispiel:

```php
$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()` kombiniert, um entweder nach einer bestimmten `pid` zu filtern oder den `header` nach einem speziellen Begriff zu durchsuchen.

### `INNER JOIN`

Ein `INNER JOIN` wird verwendet, um Daten aus mehreren Tabellen zu verbinden. Hier verknüpfen wir die Tabellen `table_content` und `pages`, basierend auf der `pid` und der `uid` von `pages`:

```php
$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 eingesetzt, wenn wir alle Zeilen aus der linken Tabelle und die passenden Zeilen aus der rechten Tabelle zurückgeben möchten, auch wenn keine Übereinstimmung in der rechten Tabelle vorhanden ist.

```php
$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 QueryBuilder können wir auch `UPDATE`-Abfragen durchführen. Hier aktualisieren wir den `header` in der `table_content`-Tabelle, wenn die `uid` gleich einer bestimmten Zahl ist:

```php
$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 QueryBuilder kann auch eine `DELETE`-Abfrage ausgeführt werden. In dem folgenden Code löschen wir alle Einträge aus der `table_content`-Tabelle, deren `pid` gleich 11 ist:

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

Tipp [TYPO3 ist ein CMS mit großer Funktionsvielfalt](https://www.ionos.at/digitalguide/hosting/cms/typo3-ein-cms-mit-grosser-funktionsvielfalt/). Wer mehr über TYPO3 lernen möchte, kann in unserem separaten Ratgeber erfahren, wie man eine [TYPO3-Website erstellt](https://www.ionos.at/digitalguide/websites/webseiten-erstellen/typo3-website-erstellen/). Außerdem finden Sie im Digital Guide eine ausführlich [TYPO3-Installationsanleitung](https://www.ionos.at/digitalguide/hosting/cms/typo3-installieren-anleitung/).


This is a markdown version of: [https://www.ionos.at/digitalguide/hosting/cms/typo3-querybuilder/](https://www.ionos.at/digitalguide/hosting/cms/typo3-querybuilder/) for AI/LLM consumption.