Abschnitt 14 · Lektion 3
Abfragen
$db->query(...) gibt nicht die gefundenen Zeilen zurück. Willst du daraus mit
$ergebnis[0]["titel"] den ersten Titel lesen, bricht das Skript mit
Cannot use object of type PDOStatement as array ab. Das ist ein Error, und er heißt, dass ein
Objekt wie ein Array benutzt wurde.
In der Variablen liegt ein Ergebnisobjekt, ein PDOStatement. Die Zeilen stecken darin und kommen
erst heraus, wenn man sie abholt. Dafür hat PDO drei Methoden.
query() ist nur für Abfragen gedacht, in denen kein Wert von außen steckt. Soll ein Suchwort aus
einem Formular oder eine Nummer aus der Adresszeile in die Abfrage, ist query() der falsche Weg.
Den richtigen gibt es in der nächsten Lektion. Alle Abfragen hier stehen deshalb fest im Quelltext.
fetchAll oder fetch
<?php
declare(strict_types=1);
// Legt die Tabelle an und fuellt sie mit acht Notizen. Dieselbe
// Verbindung wie in Lektion 14.2, nur mit einer Spalte mehr.
//
// Die Tabelle wird bei jedem Lauf neu aufgebaut, damit du immer
// denselben Stand vor dir hast. An dieser Datei aenderst du nichts.
$db = new PDO("sqlite:" . __DIR__ . "/daten.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("DROP TABLE IF EXISTS notizen");
$db->exec("CREATE TABLE notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL,
erledigt INTEGER NOT NULL DEFAULT 0,
angelegt TEXT NOT NULL
)");
$einfuegen = $db->prepare("INSERT INTO notizen (titel, erledigt, angelegt)
VALUES (:titel, :erledigt, :angelegt)");
foreach ([
["Tee", 0, "2026-08-17"],
["Seife", 0, "2026-08-18"],
["Kerzen", 1, "2026-08-19"],
["Batterien", 0, "2026-08-20"],
["Kaffee", 0, "2026-08-22"],
["Zahnpasta", 1, "2026-08-25"],
["Brot", 0, "2026-08-23"],
["Milch", 0, "2026-08-24"],
] as [$titel, $erledigt, $angelegt]) {
$einfuegen->execute([":titel" => $titel, ":erledigt" => $erledigt, ":angelegt" => $angelegt]);
} <?php
declare(strict_types=1);
// Dieselbe Abfrage, zweimal abgeholt.
require __DIR__ . "/vorbereiten.php";
$alle = $db->query("SELECT id, titel FROM notizen ORDER BY id LIMIT 3")->fetchAll();
echo "fetchAll() liefert eine Liste von Zeilen:\n";
print_r($alle);
$eine = $db->query("SELECT id, titel FROM notizen ORDER BY id LIMIT 3")->fetch();
echo "\nfetch() liefert nur die erste, und zwar direkt als Zeile:\n";
print_r($eine);
echo "\nDeshalb kommst du an den Titel unterschiedlich heran:\n";
echo " aus fetchAll: ", $alle[0]["titel"], "\n";
echo " aus fetch: ", $eine["titel"], "\n"; fetchAll() holt alle Zeilen auf einmal und gibt ein Array von Arrays zurück. Das ist ein
verschachteltes Array, außen eine Liste mit Nummern, innen je eine Zuordnung von Spaltenname auf
Wert. Ein foreach darüber gibt eine Zeile nach der anderen.
fetch() holt eine Zeile, nämlich die nächste, und gibt sie direkt als Zuordnung zurück. An den
Wert kommst du dann mit $zeile["titel"] und nicht mit $zeilen[0]["titel"]. Das brauchst du,
wenn genau eine Zeile gesucht ist, etwa über ihre id.
Ein dritter Weg ist bequem, wenn dich nur ein einziger Wert interessiert. fetchColumn() gibt die
erste Spalte der ersten Zeile, aus SELECT count(*) FROM notizen also gleich die Zahl statt eines
Arrays mit einem Eintrag darin.
Auswählen, filtern, sortieren, abschneiden
<?php
declare(strict_types=1);
// Legt die Tabelle an und fuellt sie mit acht Notizen. Dieselbe
// Verbindung wie in Lektion 14.2, nur mit einer Spalte mehr.
//
// Die Tabelle wird bei jedem Lauf neu aufgebaut, damit du immer
// denselben Stand vor dir hast. An dieser Datei aenderst du nichts.
$db = new PDO("sqlite:" . __DIR__ . "/daten.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("DROP TABLE IF EXISTS notizen");
$db->exec("CREATE TABLE notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL,
erledigt INTEGER NOT NULL DEFAULT 0,
angelegt TEXT NOT NULL
)");
$einfuegen = $db->prepare("INSERT INTO notizen (titel, erledigt, angelegt)
VALUES (:titel, :erledigt, :angelegt)");
foreach ([
["Tee", 0, "2026-08-17"],
["Seife", 0, "2026-08-18"],
["Kerzen", 1, "2026-08-19"],
["Batterien", 0, "2026-08-20"],
["Kaffee", 0, "2026-08-22"],
["Zahnpasta", 1, "2026-08-25"],
["Brot", 0, "2026-08-23"],
["Milch", 0, "2026-08-24"],
] as [$titel, $erledigt, $angelegt]) {
$einfuegen->execute([":titel" => $titel, ":erledigt" => $erledigt, ":angelegt" => $angelegt]);
} <?php
declare(strict_types=1);
// Dieselbe Abfrage in vier Stufen. Das Ergebnis wird kleiner
// und dreht sich.
require __DIR__ . "/vorbereiten.php";
$stufen = [
"ohne Zusatz" => "SELECT titel FROM notizen",
"WHERE erledigt = 0" => "SELECT titel FROM notizen WHERE erledigt = 0",
"dazu ORDER BY angelegt DESC" => "SELECT titel FROM notizen WHERE erledigt = 0 ORDER BY angelegt DESC",
"dazu LIMIT 3" => "SELECT titel FROM notizen WHERE erledigt = 0 ORDER BY angelegt DESC LIMIT 3",
];
foreach ($stufen as $was => $sql) {
$titel = [];
foreach ($db->query($sql) as $zeile) {
$titel[] = $zeile["titel"];
}
echo $was, "\n";
echo " ", count($titel), " Zeilen: ", implode(", ", $titel), "\n\n";
} Im Beispiel entsteht dieselbe Abfrage in vier Stufen, und jede ändert etwas am Ergebnis.
SELECT titel FROM notizen ist die Grundform. Sie sagt, welche Spalten aus welcher Tabelle kommen.
Ein * statt der Spaltennamen heißt „alle Spalten“ und ist zum Ausprobieren praktisch. In fertigem
Code nennt man lieber die Spalten, die man braucht, denn dann sieht man beim Lesen, womit er
arbeitet.
WHERE erledigt = 0 ist die Bedingung, und aus acht Zeilen werden sechs. Bedingungen lassen sich
mit AND und OR verbinden. Für eine Textsuche gibt es LIKE, und darin steht % für beliebig
viele Zeichen (ein Joker, englisch wildcard).
ORDER BY angelegt DESC sortiert. Die Zahl der Zeilen bleibt, nur die Reihenfolge dreht sich um.
DESC heißt absteigend, ASC aufsteigend, und ohne Angabe gilt aufsteigend. Sortiert wird nach
dem, was in der Spalte steht. Die Daten sind als 2026-08-24 abgelegt, und so sortiert sich das
Datum von selbst richtig.
LIMIT 3 schneidet ab. Erst jetzt werden aus sechs Zeilen drei, und die Reihenfolge davor
entscheidet, welche drei. Ein LIMIT ohne ORDER BY liefert irgendwelche drei Zeilen. Heute
vielleicht andere als morgen.
Was zurückkommt, wenn nichts da ist
<?php
declare(strict_types=1);
// Legt die Tabelle an und fuellt sie mit acht Notizen. Dieselbe
// Verbindung wie in Lektion 14.2, nur mit einer Spalte mehr.
//
// Die Tabelle wird bei jedem Lauf neu aufgebaut, damit du immer
// denselben Stand vor dir hast. An dieser Datei aenderst du nichts.
$db = new PDO("sqlite:" . __DIR__ . "/daten.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("DROP TABLE IF EXISTS notizen");
$db->exec("CREATE TABLE notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL,
erledigt INTEGER NOT NULL DEFAULT 0,
angelegt TEXT NOT NULL
)");
$einfuegen = $db->prepare("INSERT INTO notizen (titel, erledigt, angelegt)
VALUES (:titel, :erledigt, :angelegt)");
foreach ([
["Tee", 0, "2026-08-17"],
["Seife", 0, "2026-08-18"],
["Kerzen", 1, "2026-08-19"],
["Batterien", 0, "2026-08-20"],
["Kaffee", 0, "2026-08-22"],
["Zahnpasta", 1, "2026-08-25"],
["Brot", 0, "2026-08-23"],
["Milch", 0, "2026-08-24"],
] as [$titel, $erledigt, $angelegt]) {
$einfuegen->execute([":titel" => $titel, ":erledigt" => $erledigt, ":angelegt" => $angelegt]);
} <?php
declare(strict_types=1);
// Eine Abfrage, die nichts findet. Drei Wege, drei Rueckgaben.
require __DIR__ . "/vorbereiten.php";
$sql = "SELECT * FROM notizen WHERE titel = 'Marmelade'";
echo "fetch(): "; var_dump($db->query($sql)->fetch());
echo "fetchAll(): "; var_dump($db->query($sql)->fetchAll());
echo "fetchColumn(): "; var_dump($db->query($sql)->fetchColumn());
echo "\nfalse ist nicht null:\n";
echo " false === null: ", var_export(false === null, true), "\n";
echo " false == null: ", var_export(false == null, true), "\n";
echo "\nUnd so sieht es aus, wenn du den Fall vergisst:\n";
$nichts = $db->query($sql)->fetch();
echo " Titel: ";
var_dump($nichts["titel"]);
echo " Die Warnung dazu steht auf dem Fehlerkanal.\n"; fetchAll() gibt bei null Treffern ein leeres Array zurück, und ein foreach darüber läuft einfach
nullmal durch. Einen Sonderfall braucht es nicht.
fetch() gibt dagegen false zurück, weder null noch ein leeres Array. false == null ist in
PHP wahr, false === null ist falsch. So großzügig vergleicht ==.
Bei fetch() selbst macht das noch keinen Unterschied, denn eine gefundene Zeile ist nie ein leeres
Array. Bei fetchColumn() schon. Steht in der Spalte eine 0, ist auch 0 == null wahr, und ein
echter Treffer sieht aus wie keiner. Ich prüfe in diesem Kurs bei beiden mit === false, dann muss
niemand überlegen, welche Methode gerade dran ist.
Fehlt die Prüfung, greift der Code mit $zeile["titel"] auf false zu. PHP macht daraus null und
schreibt eine Warnung auf den Fehlerkanal, Trying to access array offset on false. So heißt sie ab
PHP 8.3, unter PHP 8.2 lautet dieselbe Warnung noch
Trying to access array offset on value of type bool. Im Beispiel steht dann Titel: NULL da, und
im Terminal steht die Warnung dazu in Rot, als eigener Block. Mit php index.php 2>/dev/null fällt
der Fehlerkanal weg.
Direkt über das Ergebnis laufen
Im zweiten Beispiel steht kein fetchAll(). Das PDOStatement lässt sich auch direkt in ein
foreach stecken, und dann kommt eine Zeile nach der anderen.
Der Unterschied liegt im Speicher. fetchAll() holt alles auf einmal, und bei zwanzigtausend Zeilen
liegen alle gleichzeitig im Arbeitsspeicher, auch wenn du sie danach sowieso nur eine nach der
anderen ausgibst. Das foreach über das Ergebnisobjekt holt eine Zeile
erst dann, wenn es sie braucht. Bei drei Zeilen ist das egal, und fetchAll() liest sich besser.
In der Aufgabe sucht die Datenbank die zwei ältesten erledigten Notizen heraus, und eine Funktion fragt nach einer einzelnen.
Zum Mitnehmen
query() fragt, fetchAll() holt alle Zeilen, fetch() eine. Findet fetch() nichts, kommt false zurück, und diesen Fall prüft man ausdrücklich mit === false.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.