he sc e e ut ab ag De sg ufl Au 2. A
r
de
Fortgeschrittene Techniken für MySQL-Administratoren
High Performance MySQL Optimierung, Datensicherung, Replikation & Lastverteilung
O’Reilly
Baron Schwartz, Peter Zaitsev, Vadim Tkachenko, Jeremy D. Zawodny, Arjen Lentz & Derek J. Balling Deutsche Übersetzung von Kathrin Lichtenberg
High Performance MySQL Optimierung, Backups, Replikation und Lastverteilung 2. Auflage
Baron Schwartz, Peter Zaitsev, Vadim Tkachenko, Jeremy D. Zawodny, Arjen Lentz & Derek J. Balling
Deutsche Übersetzung von Kathrin Lichtenberg
Beijing · Cambridge · Farnham · Köln · Sebastopol · Taipei · Tokyo
Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen. Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind möglicherweise eingetragene Warenzeichen. Der Verlag richtet sich im Wesentlichen nach den Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen. Kommentare und Fragen können Sie gerne an uns richten: O’Reilly Verlag Balthasarstr. 81 50670 Köln E-Mail:
[email protected]
Copyright der deutschen Ausgabe: © 2009 by O’Reilly Verlag GmbH & Co. KG 1. Auflage 2005 2. Auflage 2009 Die Originalausgabe erschien 2008 unter dem Titel High Performance MySQL: Optimization, Backups, Replication and more, 2nd Edition bei O’Reilly Media, Inc. Die Darstellung eines Sperbers im Zusammenhang mit dem Thema MySQL ist ein Warenzeichen von O’Reilly Media, Inc.
Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar. Übersetzung und deutsche Bearbeitung: Kathrin Lichtenberg, Ilmenau Lektorat: Christine Haite, Köln Korrektorat: Friederike Daenecke, Zülpich Satz: Tim Mergemeier, Reemers Publishing Services GmbH, Krefeld; www.reemers.de Umschlaggestaltung: Karen Montgomery, Boston & Michael Oreal, Köln Produktion: Andrea Miß, Köln Belichtung, Druck und buchbinderische Verarbeitung: Druckerei Kösel, Krugzell; www.koeselbuch.de
ISBN 978-3-89721-889-5 Dieses Buch ist auf 100% chlorfrei gebleichtem Papier gedruckt.
Inhalt
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XI .............................................. 1 Die logische Architektur von MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Nebenläufigkeitskontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Transaktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Multi-Version Concurrency Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Die Storage-Engines von MySQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1 Die MySQL-Architektur
2 Engpässe finden: Benchmarking und Profiling. . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Wozu Benchmarks? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benchmarking-Strategien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benchmarking-Taktiken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benchmarking-Werkzeuge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benchmarking-Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Profiling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Profiling des Betriebssystems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36 36 41 46 48 59 82
3 Schema-Optimierung und Indizierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Optimale Datentypen auswählen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 Grundlagen der Indizierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 Indizierungsstrategien für High Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 Indizierung – eine Fallstudie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Index- und Tabellenpflege . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 Normalisierung und Denormalisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 ALTER TABLE beschleunigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156 Hinweise zu Storage-Engines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
|
V
4 Optimierung der Abfrageleistung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Grundlagen langsamer Abfragen: Datenzugriff optimieren . . . . . . . . . . . . . . . . . Methoden zum Umstrukturieren von Abfragen. . . . . . . . . . . . . . . . . . . . . . . . . . Grundlagen der Abfrageverarbeitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Grenzen des MySQL-Abfrageoptimierers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bestimmte Arten von Abfragen optimieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hinweise für den Abfrageoptimierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benutzerdefinierte Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 Erweiterte MySQL-Funktionen
...................................... Der MySQL-Abfrage-Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Code in MySQL speichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Cursor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vorbereitete Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benutzerdefinierte Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zeichensätze und Sortierreihenfolgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Volltextsuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fremdschlüsselbeschränkungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Merge-Tabellen und Partitionierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verteilte (XA-) Transaktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
163 169 172 192 202 210 213
220 220 234 242 243 248 250 255 263 272 273 283
6 Die Servereinstellungen optimieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 Grundlagen der Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Allgemeines Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Ein-/Ausgabeverhalten von MySQL anpassen . . . . . . . . . . . . . . . . . . . . . . . Die MySQL-Nebenläufigkeit anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lastbasierte Anpassungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verbindungsbezogene Werte anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7 Betriebssystem- und Hardwareoptimierung
........................... Was beschränkt die Leistung von MySQL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wie Sie CPUs für MySQL auswählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Speicher- und Festplattenressourcen abwägen. . . . . . . . . . . . . . . . . . . . . . . . . . . Hardware für einen Slave wählen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . RAID-Leistungsoptimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Storage Area Networks und Network-Attached Storage . . . . . . . . . . . . . . . . . . . Mehrere Festplatten-Volumes benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Netzwerkkonfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
VI
| Inhalt
287 293 304 320 323 330
331 332 332 336 345 345 354 355 358
Ein Betriebssystem wählen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein Dateisystem wählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Threading. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Swapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Betriebssystemstatus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8 Replikation
..................................................... Replikation im Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Replikation einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Replikation näher betrachtet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Replikationstopologien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Replikation und Kapazitätsplanung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Replikationsadministration und -wartung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Replikationsprobleme und Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wie schnell ist die Replikation? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Zukunft der MySQL-Replikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
360 361 363 364 366
373 373 377 386 393 408 410 421 441 443
9 Skalierung und Hochverfügbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MySQL skalieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lastausgleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hochverfügbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
446 448 475 487
10 Optimierung auf Anwendungsebene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498 Überblick über die Anwendungsleistung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Webserverprobleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Caching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MySQL erweitern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Alternativen zu MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
498 502 505 512 514
11 Backup und Wiederherstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Überlegungen und Kompromisse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Binärlogs organisieren und sichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Daten in einem Backup sichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wiederherstellung aus einem Backup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backup- und Wiederherstellungsgeschwindigkeit . . . . . . . . . . . . . . . . . . . . . . . . Backup-Werkzeuge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backups mit Skripten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
516 521 531 534 546 558 558 566
Inhalt | VII
12 Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Account-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Betriebssystemsicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Netzwerksicherheit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenverschlüsselung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MySQL in einer chroot-Umgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13 Der MySQL-Serverstatus
........................................... Systemvariablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SHOW STATUS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SHOW INNODB STATUS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SHOW PROCESSLIST. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SHOW MUTEX STATUS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Status der Replikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . INFORMATION_SCHEMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
570 571 592 593 601 606
608 608 609 616 631 631 633 634
14 Werkzeuge für High Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636 Schnittstellenwerkzeuge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Überwachungswerkzeuge. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Analysewerkzeuge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MySQL-Dienstprogramme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Weitere Informationsquellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
636 638 649 652 655
A Große Dateien übertragen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656 B EXPLAIN benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661 C Sphinx mit MySQL benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677 D Sperren debuggen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706 Index
...............................................................
VIII | Inhalt
717
Vorwort
Wir hatten für dieses Buch verschiedene Ziele im Sinn. Viele von ihnen rührten daher, dass wir über das sagenumwobene perfekte MySQL-Buch nachdachten, das noch niemand von uns zu Gesicht bekommen hatte, nach dem wir jedoch in den Regalen der Buchläden Ausschau hielten. Andere Ideen stammten aus unseren umfassenden Erfahrungen, die wir sammelten, wenn wir anderen Benutzern halfen, MySQL in ihren Umgebungen zum Laufen zu bringen. Wir wollten ein Buch, das nicht nur ein SQL-Einstieg ist. Wir wollten ein Buch mit einem Titel, der nicht in einem beliebigen Zeitrahmen begann oder endete (»…in 30 Tagen«, »In sieben Tagen zu besseren…«) und nicht von oben herab auf den Leser »einredete«. Vor allem wollten wir ein Buch, das Ihnen helfen würde, Ihre Fähigkeiten auf die nächste Stufe zu bringen und schnelle, zuverlässige Systeme mit MySQL aufzubauen – eines, das Fragen beantworten würde wie: »Wie kann ich einen Cluster aus MySQL-Servern einrichten, die in der Lage sind, Millionen und Abermillionen von Abfragen zu verarbeiten, und sicherstellen, dass alles weiter funktioniert, auch wenn einige der Server sterben?« Wir beschlossen, ein Buch zu schreiben, das sich nicht nur auf die Bedürfnisse der MySQL-Anwendungsentwickler konzentrierte, sondern auch auf die rigorosen Anforderungen des MySQL-Administrators, der das System am Laufen halten muss, was auch immer die Programmierer oder Benutzer dem Server zumuten. Infolgedessen gehen wir davon aus, dass Sie bereits relativ erfahren mit MySQL sind und idealerweise ein einführendes Buch darüber gelesen haben. Wir setzen außerdem eine gewisse Erfahrung mit der allgemeinen Systemadministration, dem Betrieb von Netzwerken und Unix-artigen Betriebssystemen voraus. Diese überarbeitete und erweiterte zweite Auflage enthält eine tiefergehende Behandlung all der Themen aus der ersten Auflage sowie viele neue Themen. Zum Teil ist dies eine Reaktion auf die Änderungen, die seit der ersten Veröffentlichung des Buches stattgefunden haben: MySQL ist jetzt eine viel größere und komplexere Software. Genauso wichtig: Seine Beliebtheit hat stark zugenommen. Die MySQL-Community ist sehr gewachsen, und große Unternehmen setzen MySQL inzwischen für ihre entscheidenden Anwendungen ein. Seit der ersten Auflage wird MySQL als vollwertige Software für den
| IX
Einsatz in Unternehmen angesehen.1 Es wird immer mehr auch für Anwendungen im Internet eingesetzt, wo Ausfallzeiten und andere Probleme nicht verschleiert oder toleriert werden können. Aus diesem Grund hat diese zweite Auflage einen etwas anderen Schwerpunkt als die erste Auflage. Wir betonen die Zuverlässigkeit und Korrektheit fast genauso stark wie die Performance – zum Teil, weil wir MySQL selbst für Anwendungen einsetzt haben, bei denen nicht unwesentliche Mengen Geldes vom Datenbankserver abhängen. Wir verfügen außerdem über umfassende Erfahrungen mit Webanwendungen, bei denen MySQL sehr populär geworden ist. Die zweite Auflage spricht die erweiterte Welt von MySQL an, die in dieser Form noch nicht existierte, als die erste Auflage erschienen ist.
Wie dieses Buch aufgebaut ist Wir haben in dieses Buch eine Menge komplizierter Themen aufgenommen. Hier wollen wir erklären, in welcher Reihenfolge wir sie zusammengestellt haben, damit sie leichter zu lernen sind.
Ein breiter Überblick Kapitel 1, Die MySQL-Architektur, widmet sich den Grundlagen – Dingen, mit denen Sie vertraut sein müssen, bevor Sie tiefer einsteigen. Sie müssen verstehen, wie MySQL organisiert ist, bevor Sie in der Lage sind, es effektiv zu benutzen. Dieses Kapitel erläutert die Architektur von MySQL und liefert wesentliche Fakten über seine Storage-Engines. Es hilft Ihnen beim Einstieg, falls Sie nicht mit den Grundlagen relationaler Datenbanken, inklusive Transaktionen, vertraut sind. Dieses Kapitel ist auch ganz nützlich, wenn dieses Buch Ihr Einstieg in MySQL ist, Sie sich aber schon mit einer anderen Datenbank, wie etwa Oracle, auskennen.
Eine solide Grundlage bauen Die nächsten vier Kapitel behandeln Material, auf das Sie immer wieder stoßen werden, wenn Sie MySQL benutzen. Kapitel 2, Engpässe finden: Benchmarking und Profiling, diskutiert die Grundlagen des Benchmarkings und Profilings – d.h., wie Sie feststellen, mit welcher Art von Arbeitsbelastung Ihr Server umgehen kann, wie schnell er bestimmte Aufgaben ausführen kann usw. Sie werden Ihre Anwendung sowohl vor als auch nach einer großen Änderung einem Benchmark-Test unterziehen, damit Sie beurteilen können, wie effektiv Ihre Änderungen sind. Was wie eine positive Änderung scheint, könnte sich unter realem Stress als negativ herausstellen, und Sie werden nie wissen, was wirklich eine schlechte Leistung verursacht, wenn Sie es nicht exakt messen. 1 Wir glauben, dass diese Phrase im Wesentlichen Marketing-Geblubber ist, sie scheint aber für viele Leute eine gewisse Wichtigkeit zu vermitteln.
X
| Vorwort
In Kapitel 3, Schema-Optimierung und Indizierung, behandeln wir die verschiedenen Nuancen der Datentypen, Tabellendesigns und Indizes. Ein gut gestaltetes Schema unterstützt MySQL bei der Arbeit. Viele der Dinge, die wir in späteren Kapiteln besprechen, sind davon abhängig, wie gut Ihre Anwendung die Indizes von MySQL zum Laufen bringt. Ein solides Verständnis der Indizes und ihrer Verwendung ist entscheidend für die effektive Benutzung von MySQL, so dass Sie wahrscheinlich öfter einmal zu diesem Kapitel zurückkehren werden. Kapitel 4, Optimierung der Abfrageleistung, erläutert, wie MySQL Abfragen ausführt und wie Sie die Stärken seines Abfrageoptimierers ausnutzen können. Ein sicheres Gespür dafür, wie der Abfrageoptimierer funktioniert, wirkt Wunder für Ihre Abfragen und hilft Ihnen dabei, die Indizes besser zu verstehen. (Indizierung und Abfrageoptimierung stellen eine Art Henne-Ei-Problem dar; möglicherweise hilft es, Kapitel 3 erneut zu lesen, wenn Sie mit Kapitel 4 fertig sind.) Dieses Kapitel präsentiert außerdem besondere Beispiele für praktisch alle gebräuchlichen Klassen von Abfragen, womit verdeutlicht wird, wo MySQL gute Arbeit leistet und wie man Abfragen in Formen umwandelt, die seine Stärken ausnutzen. Bis zu dieser Stelle haben wir die Grundlagen behandelt, die für jede Datenbank gelten: Tabellen, Indizes, Daten und Abfragen. Kapitel 5, Erweiterte MySQL-Funktionen, geht über die Grundlagen hinaus und zeigt Ihnen, wie die erweiterten Funktionen von MySQL arbeiten. Wir untersuchen den Abfrage-Cache, gespeicherte Prozeduren, Trigger, Zeichensätze und mehr. MySQLs Implementierung dieser Merkmale unterscheidet sich von der anderer Datenbanken, und ein gutes Verständnis dafür kann neue Möglichkeiten für Leistungsgewinne öffnen, die Sie möglicherweise sonst nicht erkannt hätten.
Ihre Anwendung verbessern In den nächsten beiden Kapiteln besprechen wir, wie man Änderungen vornimmt, um die Leistung Ihrer MySQL-basierten Anwendung zu verbessern. In Kapitel 6, Die Servereinstellungen optimieren, erläutern wir, wie Sie MySQL so einstellen, dass es das meiste aus Ihrer Hardware herausholt und so gut wie möglich für Ihre spezielle Anwendung funktioniert. Kapitel 7, Betriebssystem- und Hardwareoptimierung, zeigt, wie Sie das Betriebssystem und die Hardware am besten ausnutzen. Wir schlagen außerdem Hardware-Konfigurationen vor, die eine bessere Leistung für größere Anwendungen liefern.
Erweiterungen nach Änderungen Ein Server reicht nicht immer aus. In Kapitel 8, Replikation, besprechen wir die Replikation, d.h., wie Sie Ihre Daten automatisch auf mehrere Server kopiert bekommen. Kombiniert mit Skalierung, Lastausgleich und den Lektionen über Hochverfügbarkeit in Kapitel 9, Skalierung und Hochverfügbarkeit, bietet Ihnen das die Grundlage, um Ihre Anwendungen so zu skalieren, wie Sie sie brauchen.
Vorwort | XI
Eine Anwendung, die auf einem groß ausgebauten MySQL-Backend läuft, bietet oft wesentliche Möglichkeiten zur Optimierung in der Anwendung selbst. Es gibt bessere und schlechtere Methoden, um große Anwendungen zu gestalten. Sie sollen über den Tellerrand von MySQL hinaussehen. Kapitel 10, Optimierung auf Anwendungsebene, hilft Ihnen dabei, zu verbessernde Schwachstellen in Ihrer Gesamtarchitektur zu erkennen, vor allem, wenn es sich um eine Webanwendung handelt.
Ihre Anwendung zuverlässig machen Auch die am besten gestaltete, gut skalierbare Architektur nützt nichts, wenn sie Stromausfälle, bösartige Angriffe, Fehler in der Anwendung oder der Programmierung und andere Katastrophen nicht überstehen kann. In Kapitel 11, Backup und Wiederherstellung, diskutieren wir die verschiedenen Backupund Wiederherstellungsstrategien für Ihre MySQL-Datenbanken. Diese Strategien helfen Ihnen dabei, Ausfallzeiten zu minimieren, falls irgendwann (was unweigerlich geschehen wird) die Hardware kaputtgeht, und sie helfen Ihnen sicherzustellen, dass Ihre Daten solche Katastrophen überleben. Kapitel 12, Sicherheit, bietet Ihnen einen soliden Einblick in einige der Sicherheitsprobleme, die mit dem Betrieb eines MySQL-Servers verbunden sind. Noch wichtiger: Wir machen viele Vorschläge, mit deren Hilfe Sie verhindern können, dass Außenstehende die Server beschädigen, die Sie die ganze Zeit zu konfigurieren und zu optimieren versuchen. Wir erläutern einige der selten erkundeten Bereiche der Datenbanksicherheit, wobei wir Ihnen sowohl die Vorteile als auch die Auswirkungen auf die Performance der verschiedenen Praktiken zeigen. In Bezug auf die Leistung zahlt es sich normalerweise aus, einfache und klare Sicherheitsstrategien zu wählen.
Verschiedene nützliche Themen In den letzten Kapiteln und den Anhängen des Buches befassen wir uns mit verschiedenen Themen, die entweder in keines der früheren Kapitel »passen« oder auf die in anderen Kapiteln so oft verwiesen wird, dass sie ein wenig mehr Aufmerksamkeit verdienen. Kapitel 13, Der MySQL-Serverstatus, zeigt Ihnen, wie Sie Ihren MySQL-Server untersuchen. Es ist wichtig zu wissen, wie man Statusinformationen vom Server gewinnt. Noch wichtiger ist es, die Bedeutung dieser Informationen zu kennen. Besonders ausführlich behandeln wir SHOW INNODB STATUS, weil dies Ihnen einen tiefen Einblick in die Operationen der transaktionsfähigen Storage-Engine InnoDB bietet. Kapitel 14, Werkzeuge für High Performance, stellt Werkzeuge vor, mit denen Sie MySQL effizienter verwalten. Dazu gehören Überwachungs- und Analysewerkzeuge, Werkzeuge zum Schreiben von Abfragen usw. Dieses Kapitel behandelt die Maatkit-Werkzeuge von Baron, mit denen Sie die Funktionalität von MySQL erweitern und sich das Leben als Datenbankadministrator erleichtern können. Es zeigt außerdem ein Programm namens innotop, das Baron als leicht zu bedienende Schnittstelle zu dem, was Ihr MySQL-Server gerade tut, geschrieben hat. Es funktioniert fast wie das Unix-Programm top und kann in
XII | Vorwort
allen Phasen des Einstellungsprozesses gute Dienste leisten, indem es überwacht, was innerhalb von MySQL und seinen Storage-Engines geschieht. Anhang A, Große Dateien übertragen, zeigt Ihnen, wie Sie effizient sehr große Dateien von einer Stelle zur anderen kopieren – ein Muss, wenn Sie große Datenvolumen verwalten. In Anhang B, EXPLAIN benutzen, erfahren Sie, wie Sie den überaus wichtigen EXPLAIN-Befehl verwenden. Anhang C, Sphinx mit MySQL benutzen, ist eine Einführung in Sphinx, ein High-Performance-Volltextindizierungssystem, das die MySQL-eigenen Fähigkeiten ergänzt. Und Anhang D, Sperren debuggen, schließlich zeigt Ihnen, wie Sie entschlüsseln, was passiert, wenn Abfragen Locks anfordern, die einander stören.
Software-Versionen und Verfügbarkeit MySQL ist ständig in der Weiterentwicklung begriffen. Seit Jeremy den Entwurf für die erste Auflage dieses Buches geschrieben hat, sind zahlreiche Versionen von MySQL erschienen. MySQL 4.1 und 5.0 gab es nur als Alpha-Versionen, als die erste Auflage in den Druck ging, aber diese Versionen sind inzwischen seit Jahren im täglichen Einsatz und bilden heute das Rückgrat vieler großer Online-Anwendungen. Als wir diese zweite Auflage abgeschlossen haben, waren stattdessen MySQL 5.1 und 6.0 der neueste Schrei. (MySQL 5.1 ist ein Release-Kandidat, und 6.0 ist im Alpha-Stadium.) Wir haben uns für dieses Buch nicht auf eine einzige Version von MySQL versteift, sondern haben unser umfangreiches kollektives Wissen über MySQL in der echten Welt ins Rennen geworfen. Der Kern dieses Buches konzentriert sich auf MySQL 5.0, weil wir dies als die »aktuelle« Version ansehen. Die meisten unserer Beispiele gehen davon aus, dass Sie eine einigermaßen ausgereifte Version von MySQL 5.0 betreiben, wie etwa MySQL 5.0.40 oder neuer. Wir haben versucht, Eigenschaften oder Funktionalitäten anzugeben, die in älteren Ausgaben nicht existieren oder die es nur in der kommenden 5.1-Serie gibt. Allerdings ist die definitive Referenz zum Zuordnen von Funktionen zu bestimmten Versionen die MySQLDokumentation selbst. Wir erwarten, dass Sie von Zeit zu Zeit in der angegebenen OnlineDokumentation (http://dev.mysql.com/doc/) nachsehen, während Sie dieses Buch lesen. Ein weiterer großartiger Aspekt von MySQL ist, dass es auf allen heute verbreiteten Plattformen läuft: Mac OS X, Windows, GNU/Linux, Solaris, FreeBSD – was Sie wollen! Wir richten uns jedoch vorrangig an Nutzer von GNU/Linux2 und anderen Unix-artigen Betriebssystemen. Windows-Benutzer werden wahrscheinlich einige Unterschiede bemerken. Zum Beispiel sind die Dateipfade völlig anders. Wir verweisen darüber hinaus auf die normalen Unix-Kommandozeilenprogramme; wir gehen davon aus, dass Sie die entsprechenden Befehle unter Windows kennen.3
2 Um Verwirrung zu vermeiden, beziehen wir uns auf Linux, wenn wir über den Kernel schreiben, und auf GNU/Linux, wenn wir über die gesamte Betriebssysteminfrastruktur schreiben, die die Anwendungen unterstützt. 3 Sie erhalten Windows-kompatible Versionen der Unix-Dienstprogramme unter http://unxutils.sourceforge.net oder unter http://gnuwin32.sourceforge.net.
Vorwort
| XIII
Perl ist der andere Knackpunkt, wenn es um MySQL unter Windows geht. MySQL enthält eine Reihe nützlicher Dienstprogramme, die in Perl geschrieben sind, und verschiedene Kapitel in diesem Buch präsentieren beispielhaft Perl-Skripten, die die Grundlage der komplexeren Werkzeuge bilden, die Sie aufbauen. Maatkit ist ebenfalls in Perl geschrieben. Allerdings ist Perl nicht in Windows enthalten. Um diese Skripten zu benutzen, müssen Sie sich eine Windows-Version von Perl von ActiveState herunterladen und die notwendigen Zusatzmodule (DBI und DBD::mysql) für den MySQL-Zugriff installieren.
Konventionen in diesem Buch Folgende typografische Konventionen kommen in diesem Buch zum Einsatz: Kursiv Wird für neue Begriffe, URLs, E-Mail-Adressen, Benutzernamen, Hostnamen, Dateinamen, Dateierweiterungen, Pfadnamen, Verzeichnisse sowie Unix-Befehle und -Dienstprogramme verwendet. Nichtproportionalschrift
Kennzeichnet Codeelemente, Konfigurationsoptionen, Datenbank- und Tabellennamen, Variablen und deren Werte, Funktionen, Module, den Inhalt von Dateien oder die Ausgabe von Befehlen. Nichtproportionalschrift fett
Zeigt Befehle oder anderen Text, der so, wie er ist, vom Benutzer eingegeben werden soll. Wird auch zum Hervorheben in Befehlsausgaben benutzt. Nichtproportionalschrift kursiv
Zeigt Text, der durch Werte ersetzt werden soll, die der Benutzer angibt. Dieses Icon kennzeichnet einen Tipp, einen Vorschlag oder eine allgemeine Anmerkung.
Dieses Icon kennzeichnet eine Warnung oder einen Achtungshinweis.
Die Codebeispiele benutzen Dieses Buch soll Ihnen helfen, Ihre Arbeit zu erledigen. Im Allgemeinen dürfen Sie den Code aus diesem Buch in Ihren Programmen und Dokumentationen einsetzen. Sie müssen uns nicht um Erlaubnis fragen, es sei denn, Sie reproduzieren einen wesentlichen Teil des Codes. Es ist z.B. keine Erlaubnis erforderlich, wenn Sie ein Programm schreiben, das einige Teile des Codes aus diesem Buch benutzt. Wenn Sie dagegen eine CD-ROM mit Beispielen aus O’Reilly-Büchern verteilen oder verkaufen, ist eine Erlaubnis nötig. Das Beantworten einer Frage, indem dieses Buch sowie Beispielcode daraus zitiert werden, XIV | Vorwort
erfordert keine Erlaubnis. Fügen Sie dagegen einen wesentlichen Anteil Beispielcode aus diesem Buch in die Dokumentation Ihres Produkts ein, ist eine Erlaubnis nötig. Die Beispiele stehen auf der Site http://www.highperfmysql.com und werden gelegentlich aktualisiert. Wir können jedoch den Code nicht für jedes kleine Release von MySQL aktualisieren und testen. Wir freuen uns über eine Quellenangabe, bestehen aber nicht darauf. Eine Quellenangabe besteht normalerweise aus Titel, Autor, Verlag und ISBN. Zum Beispiel: »High Performance MySQL/Optimierung, Backups, Replikation und Lastverteilung, 2. Auflage, von Baron Schwartz et al. Copyright 2009, O’Reilly Verlag, ISBN 9783897218895.« Falls Sie das Gefühl haben, dass Ihre Benutzung des Codes durch die oben angegebenen Umstände nicht abgedeckt ist, dann schreiben Sie einfach an
[email protected].
Wie Sie mit uns in Verbindung treten Sie können mit den Autoren direkt Kontakt aufnehmen. Barons Weblog finden Sie unter http://www.xaprb.com. Peter und Vadim betreiben zwei Weblogs, das etablierte und beliebte http://www.mysqlperformanceblog.com und das neuere http://www.webscalingblog.com. Sie finden die Website ihrer Firma, Percona, unter http://www.percona.com. Arjens Unternehmen, OpenQuery, besitzt eine Website unter http://openquery.com.au. Arjen betreibt ebenfalls ein Weblog unter http://arjen-lentz.livejournal.com und eine persönliche Site unter http://lentz.com.au.
Danksagungen für die zweite Auflage Sphinx-Entwickler Andrew Aksyonoff schrieb Anhang C, Sphinx mit MySQL benutzen. Wir wollen ihm für seine ausführliche Beschreibung danken. Wir haben beim Schreiben dieses Buches von vielen Leuten unschätzbare Hilfe erhalten. Es ist unmöglich, hier alle aufzuzählen – wir schulden der gesamten MySQL-Gemeinde sowie den Leuten bei MySQL AB unseren Dank. Hier ist eine Liste der Leute, die direkt etwas beigetragen haben; wir entschuldigen uns gleich bei denen, die wir vergessen haben: Tobias Asplund, Igor Babaev, Pascal Borghino, Roland Bouman, Ronald Bradford, Mark Callaghan, Jeremy Cole, Britt Crawford und das HiveDB-Projekt, Vasil Dimov, Harrison Fisk, Florian Haas, Dmitri Joukovski und Zmanda (danke für das Diagramm, das LVM-Schnappschüsse erläutert), Alan Kasindorf, Sheeri Kritzer Cabral, Marko Makela, Giuseppe Maxia, Paul McCullagh, B. Keith Murphy, Dhiren Patel, Sergey Petrunia, Alexander Rubin, Paul Tuckfield, Heikki Tuuri und Michael »Monty« Widenius. Ein besonderer Dank geht an Andy Oram, Isabel Kunkle und Rachel Wheeler, das Lektorenteam bei O’Reilly. Danke auch an den Rest der O’Reilly-Mannschaft.
Vorwort |
XV
Von Baron Ich möchte meiner Frau Lynn Rainville und unserem Hund Carbon danken. Wenn Sie ein Buch geschrieben hätten, dann wüssten Sie sicher, wie dankbar ich ihnen bin. Ganz besonderen Dank schulde ich außerdem Alan Rimm-Kaufman und meinen Kollegen bei der Rimm-Kaufman-Gruppe für ihre Unterstützung und Ermutigung während dieses Projekts. Danke an Peter, Vadim und Arjen dafür, dass sie mir die Möglichkeit gaben, meinen Traum zu verwirklichen. Und danke an Jeremy und Derek dafür, dass sie den Weg für uns gebahnt haben.
Von Peter Seit Jahren führe ich MySQL-Leistungs- und Skalierungspräsentationen, Schulungen und Beratungen durch und wollte immer ein breiteres Publikum erreichen. Deshalb war ich sehr aufgeregt, als Andy Oram an mich herantrat und mich bat, bei diesem Buch mitzuarbeiten. Ich habe vorher noch kein Buch geschrieben, war also nicht darauf vorbereitet, wie viel Zeit und Aufwand so etwas erfordert. Zuerst sprachen wir nur darüber, die erste Auflage zu aktualisieren, um neuere Versionen von MySQL einzubeziehen. Wir wollten aber so viel Material aufnehmen, dass wir schließlich den größten Teil des Buches neu schrieben. Dieses Buch ist wirklich eine Teamleistung. Da ich sehr damit beschäftigt war, Percona, Vadims und meine Beratungsfirma, in Gang zu bringen, und Englisch nicht meine Muttersprache ist, spielten wir alle unterschiedliche Rollen. Ich lieferte den Entwurf und den technischen Inhalt, anschließend sichtete ich das Material, wobei ich es während des Schreibens überarbeitete und erweiterte. Als Arjen (früherer Kopf des MySQL-Dokumentationsteams) zum Projekt stieß, begannen wir damit, den Entwurf mit Leben zu füllen. Die Dinge kamen dann wirklich ins Rollen, als Baron hinzukam, der in wahnwitziger Geschwindigkeit qualitativ hochwertigen Inhalt schreiben kann. Vadim war eine große Hilfe bei den tiefgehenden MySQL-Quellcodetests und wenn wir unsere Behauptungen mit Benchmarks und anderen Untersuchungen untermauern mussten. Während der Arbeit an dem Buch fanden wir immer mehr Bereiche, die wir genauer erkunden wollten. Viele der Themen des Buches, wie etwa Replikation, Abfrageoptimierung, InnoDB, Architektur und Entwurf, könnten leicht eigene Bücher füllen, so dass wir irgendwo aufhören und Material für eine künftige Auflage oder für unsere Blogs, Präsentationen und Artikel lassen mussten. Umfangreiche Hilfe bekamen wir von unseren Gutachtern, die zu den echten MySQLExperten, sowohl innerhalb als auch außerhalb von MySQL AB, gehören. Das sind der MySQL-Begründer Michael Widenius, der InnoDB-Begründer Heikki Tuuri, Igor Babaev, der Chef des MySQL-Optimiererteams, und viele andere.
XVI |
Vorwort
Außerdem danke ich meiner Frau Katya Zaytseva und meinen Kindern Ivan und Nadezhda, dass sie mir erlaubt haben, Zeit, die eigentlich der Familie gewidmet sein sollte, mit dem Buch zu verbringen. Ich bin darüber hinaus den Angestellten von Percona dankbar, dass sie eingesprungen sind, wenn ich verschwand, um an dem Buch zu arbeiten, und natürlich Andy Oram und O’Reilly, dass sie das Buch ermöglicht haben.
Von Vadim Ich danke Peter, mit dem ich wunderbar an diesem Buch zusammengearbeitet habe und auch gern andere Projekte durchführen würde, Baron, der entscheidend dafür verantwortlich ist, dass dieses Buch zustande kam, und Arjen, mit dem zu arbeiten mir viel Spaß macht. Dank gebührt auch unserem Lektor Andy Oram, der viel Geduld mit uns hatte, dem MySQL-Team, das eine großartige Software geschaffen hat, und unseren Kunden, die mir die Möglichkeiten geboten haben, mein MySQL-Verständnis zu schärfen. Und schließlich geht ein besonderer Dank an meine Frau Valerie und unsere Söhne Myroslav und Timur, die mich immer unterstützen und mir helfen voranzukommen.
Von Arjen Ich danke Andy für seine Klugheit, Führung und Geduld. Mein Dank gilt Baron, der auf den Zug zur zweiten Auflage aufgesprungen ist, obwohl er sich schon in Bewegung gesetzt hatte, und Peter und Vadim für die soliden Hintergrundinformationen und Benchmarks. Ein Dank geht auch an Jeremy und Derek, die mit der ersten Auflage das Fundament geschaffen haben. Wie Du, Derek, in meine Kopie geschrieben hast: »Macht es ordentlich, mehr will ich nicht.« Ich danke ebenfalls meinen früheren Kollegen (und jetzigen Freunden) von MySQL AB, wo ich das meiste erfahren habe, was ich über das Thema weiß, und ich möchte in diesem Zusammenhang vor allem Monty erwähnen, den ich weiterhin als stolzen Vater von MySQL betrachte, auch wenn sein Unternehmen jetzt Teil von Sun Microsystems ist. Ich danke außerdem allen anderen in der globalen MySQL-Gemeinschaft. Und last but not least, danke ich meiner Tochter Phoebe, die sich in dieser Phase ihres Lebens noch nicht um das Ding namens »MySQL« kümmert und auch keine Ahnung hat, welcher der Wiggles (die australische Popband, nicht die Zwerge) damit gemeint sein könnte! Für manche ist Ignoranz ein wahrer Segen, und sie bieten uns eine erfrischende Sicht auf die Dinge, die wirklich wichtig sind im Leben. Für alle anderen ist dieses Buch hoffentlich eine sinnvolle Ergänzung im Bücherschrank. Und vergessen Sie nicht zu leben!
Vorwort | XVII
Danksagungen für die erste Auflage Ein Buch wie dieses würde ohne die Hilfe Dutzender Menschen nie Wirklichkeit werden. Ohne sie wäre das Buch, das Sie gerade in den Händen halten, nur ein Haufen an den Rändern unserer Monitore angebrachter Notizen. Dies ist der Teil des Buches, in dem wir über die Leute, die uns geholfen haben, sagen dürfen, was wir wollen. Und wir müssen uns keine Sorgen machen, dass im Hintergrund Musik ertönt, die uns auffordert, den Mund zu halten und zu verschwinden, wie man das von Preisverleihungen im Fernsehen kennt. Wir hätten dieses Projekt ohne das ständige Drängeln, Betteln, Fordern und die Unterstützung unseres Lektors Andy Oram niemals abschließen können. Wenn es eine Person gibt, die dafür verantwortlich ist, dass Sie dieses Buch in den Händen halten, dann ist es Andy. Wir wissen die wöchentlichen Meckerrunden wirklich zu schätzen. Aber natürlich ist Andy nicht allein. Bei O’Reilly hatte eine ganze Menge anderer Leute ihren Anteil daran, dass aus den am Monitor befestigten Notizen das Buch wurde, das Sie gerade lesen möchten, deshalb wollen wir an dieser Stelle auch den Produktions-, Grafikund Marketingleuten danken, die uns dabei behilflich waren, dieses Buch zu schaffen. Und natürlich geht unser Dank auch an Tim O’Reilly für sein fortwährendes Engagement, die beste Dokumentation zu populärer Open-Source-Software zu veröffentlichen. Abschließend geht unser Dank an die Leute, die sich bereit erklärt haben, die verschiedenen Rohfassungen dieses Buches anzuschauen und uns all die Dinge aufzuzeigen, die wir falsch gemacht haben: unsere Korrektoren. Sie haben einen Teil ihres 2003er-Urlaubs damit verbracht, sich grob formatierte Versionen dieses Textes anzuschauen, der voller Schreibfehler, irreführender Anweisungen und mathematischer Fehler war. Unser Dank geht (ohne bestimmte Reihenfolge) an Brian »Krow« Aker, Mark »JDBC« Matthews, Jeremy »the other Jeremy« Cole, Mike »VBMySQL.com« Hillyer, Raymond »Rainman« De Roo, Jeffrey »Regex Master« Friedl, Jason DeHaan, Dan Nelson, Steve »Unix Wiz« Friedl und Kasia »Unix Girl« Trapszo.
Von Jeremy Ich möchte noch einmal Andy dafür danken, dass er dieses Projekt übernommen und uns fortlaufend weitere Kapitel abgerungen hat. Dereks Hilfe war unerlässlich, um die letzten 20–30 % des Buches abschließen zu können, ohne einen weiteren Zieltermin zu verpassen. Dank dafür, dass er noch so spät in diesen Prozess eingestiegen ist, meine sporadischen Produktivitätsausbrüche verarbeitet hat und die XML-Arbeit, Kapitel 10, Anhang C und all die anderen Dinge übernommen hat, die ich auf ihn abgewälzt habe. Ich muss auch meinen Eltern danken, die mir vor so vielen Jahren den ersten Commodore 64 kauften. Sie haben nicht nur die ersten zehn Jahre alles toleriert, was nach einer lebenslangen Besessenheit für Elektronik und Computertechnik aussah, sondern unterstützten auch sehr schnell meinen nie endenden Wunsch, mehr zu lernen und zu tun.
XVIII | Vorwort
Als Nächstes möchte ich einer Gruppe von Leuten danken, mit denen ich in den vergangenen Jahren arbeiten durfte, während ich missionarisch die Lehre von MySQL bei Yahoo! verbreitete. Jeffrey Friedl und Ray Goldberger ermutigten mich seit den frühen Anfängen dieses Unternehmens und lieferten Feedback zurück. Gleichzeitig fanden sich Steve Morris, James Harvey und Sergey Kolychev mit meinen scheinbar pausenlosen Experimenten mit den Yahoo! Finance MySQL-Servern ab, auch wenn dies ihre wichtige Arbeit störte. Dank auch an die unzähligen anderen Yahoo!s, die mir dabei halfen, interessante MySQL-Probleme und -Lösungen zu finden. Und, was noch wichtiger ist, danke für das Vertrauen und den Glauben an mich, der notwendig war, um MySQL an einer der wichtigsten und sichtbarsten Stellen des Yahoo!-Geschäfts einsetzen zu dürfen. Adam Goodman, Herausgeber und Besitzer des Linux Magazine, erleichterte mir den Einstieg in die Welt des Schreibens für ein technisches Publikum, indem er meine ersten längeren MySQL-Artikel im Jahr 2001 veröffentlichte. Seither hat er mir mehr über redaktionelle Bearbeitung und Herausgabe beigebracht, als ihm bewusst war, und mich ermutigt, diesen Weg weiterzugehen, indem er mir eine eigene monatliche Kolumne in seinem Magazin gewährte. Danke, Adam. Ich danke Monty und David dafür, MySQL mit der Welt zu teilen. Und da wir gerade bei MySQL AB sind, möchte ich auch all den anderen danken, die mich ermutigt haben, dieses Buch zu schreiben: Kerry, Larry, Joe, Marten, Brian, Paul, Jeremy, Mark, Harrison, Matt und dem Rest des Teams. Ihr seid der Hammer. Schließlich möchte ich all meinen Weblog-Lesern danken, die mich ermutigt haben, jeden Tag informell über MySQL und andere technische Themen zu schreiben.
Von Derek Wie Jeremy möchte ich, aus den gleichen Gründen, meiner Familie danken. Ich möchte meinen Eltern danken, die mich fortwährend ermutigt haben, ein Buch zu schreiben, auch wenn das Ergebnis nicht dem entspricht, was sie im Sinn hatten. Meine Großeltern brachten mir zwei wertvolle Dinge bei: den Umgang mit Geld und die Liebe zu Computern (als sie mir das Geld für meinen ersten Commodore VIC-20 liehen). Ich kann Jeremy nicht genug danken, mich zu dieser Achterbahnfahrt des Buchschreibens eingeladen zu haben. Es war eine großartige Erfahrung, und ich hoffe, zukünftig wieder mit ihm arbeiten zu können. Besonderer Dank geht an Raymond De Roo, Brian Wohlgemuth, David Calafrancesco, Tera Doty, Jay Rubin, Bill Catlan, Anthony Howe, Mark O’Neal, George Montgomery, George Barber und die vielen anderen Menschen, die sich mein Meckern angehört haben, auf die ich meine Ideen loslassen durfte, um zu sehen, ob ein Außenstehender verstehen kann, was ich zu sagen versuche, oder die ein Lächeln auf meine Lippen zauberten, als ich es am meisten brauchte. Ohne euch wäre das Buch vielleicht auch geschrieben worden, aber ich wäre darüber verrückt geworden.
Vorwort | XIX
KAPITEL 1
Die MySQL-Architektur
Die MySQL-Architektur unterscheidet sich stark von der anderer Datenbankserver und ist sehr vielseitig einsetzbar. MySQL ist zwar nicht perfekt, aber dennoch so flexibel, dass es in anspruchsvollen Umgebungen, wie etwa Webanwendungen, gut funktioniert. Gleichzeitig kann MySQL eingebettete Anwendungen, Data-Warehouses, Content-Indexing- und -Delivery-Software, hochverfügbare redundante Systeme, Online Transaction Processing (OLTP) und vieles mehr versorgen. Um das meiste aus MySQL herauszuholen, müssen Sie seinen Aufbau verstehen, damit Sie mit ihm und nicht gegen es arbeiten. MySQL ist ausgesprochen flexibel. So können Sie es für den Gebrauch auf vielerlei Hardware konfigurieren, außerdem unterstützt es eine Vielzahl von Datentypen. Die ungewöhnlichste und wichtigste Eigenart von MySQL ist jedoch seine Storage-Engine-Architektur, deren Design die Verarbeitung von Abfragen sowie andere Serveraufgaben von der Datenspeicherung und -bereitstellung trennt. In MySQL 5.1 können Sie Storage-Engines sogar als Laufzeit-Plugins laden. Diese Trennung erlaubt es Ihnen, tabellenweise zu entscheiden, wie Ihre Daten gespeichert werden und welche Leistungen, Funktionen und andere Eigenschaften Sie haben wollen. Dieses Kapitel bietet einen Überblick über die MySQL-Serverarchitektur, zeigt die wesentlichen Unterschiede zwischen den Storage-Engines und erläutert, weshalb diese Unterschiede wichtig sind. Wir versuchen, MySQL zu erklären, indem wir Details vereinfachen und Beispiele zeigen. Diese Diskussion ist vor allem für Neulinge auf dem Gebiet der Datenbankserver sinnvoll sowie für Leser, die sich eher mit anderen Datenbankservern auskennen.
Die logische Architektur von MySQL Es wird Ihnen helfen, den Server zu verstehen, wenn Sie sich eine Vorstellung davon machen, wie die Komponenten von MySQL zusammenarbeiten. Abbildung 1-1 zeigt den Aufbau von MySQL aus logischer Sicht.
|
1
Clients
Verbindungs-/Thread-Verarbeitung
AbfrageCache
Parser
Optimierer
Storage-Engines
Abbildung 1-1: Logischer Aufbau der MySQL-Serverarchitektur
Die oberste Schicht enthält die Dienste, die nicht allein von MySQL verwendet werden. Diese Dienste werden von den meisten netzwerkbasierten Client/Server-Programmen oder -Servern benötigt: Behandlung von Verbindungen, Authentifizierung, Sicherheit usw. In der zweiten Schicht werden die Dinge interessant. Ein Großteil des in MySQL investierten Gehirnschmalzes liegt hier, einschließlich des Codes für Parsing, Analyse, Optimierung, Caching von Abfragen sowie alle fest eingebauten Funktionen (z.B. Datum, Zeit, Mathematik und Verschlüsselung). Jegliche Funktionalität, die über StorageEngines hinweg zur Verfügung gestellt wird, ist hier zusammengefasst: z.B. gespeicherte Prozeduren (Stored Procedures), Trigger und Sichten. Die dritte Schicht enthält die Storage-Engines (auch: Speicher-Engines). Sie sind für die Speicherung und den Abruf aller Daten verantwortlich, die »in« MySQL gespeichert werden. Wie die verschiedenen unter GNU/Linux zur Verfügung stehenden Dateisysteme besitzt jede Storage-Engine ihre Vor- und Nachteile. Der Server kommuniziert mit ihnen über die Storage-Engine-API. Diese Schnittstelle verbirgt die Unterschiede zwischen den Storage-Engines, so dass sie auf der Abfrageebene im Großen und Ganzen transparent sind. Die API enthält einige Dutzend Low-Level-Funktionen für solche Operationen wie »beginne eine Transaktion« oder »lies die Zeile mit dem Primärschlüssel«. Die StorageEngines verarbeiten weder SQL1 noch kommunizieren sie miteinander; sie reagieren einfach auf Anforderungen vom Server.
1 Eine Ausnahme bildet InnoDB, das fremde Schlüsseldefinitionen verarbeitet, weil der MySQL-Server diese nicht selbst implementiert.
2 | Kapitel 1: Die MySQL-Architektur
Verbindungsmanagement und Sicherheit Jede Clientverbindung erhält innerhalb des Serverprozesses ihren eigenen Thread. Die Abfragen der Verbindung werden in dem jeweiligen Thread ausgeführt, der sich wiederum auf einem Prozessorkern oder einer CPU befindet. Der Server speichert Threads im Cache, so dass sie bei einer neuen Verbindung nicht jedes Mal erzeugt und zerstört werden müssen.2 Wenn Clients (Anwendungen) eine Verbindung zum MySQL-Server herstellen, muss der Server sie authentifizieren. Die Authentifizierung erfolgt anhand des Benutzernamens, des Ursprungshosts und des Passworts. Über eine SSL-Verbindung (Secure Sockets Layer) können auch X.509-Zertifikate eingesetzt werden. Sobald die Verbindung zum Client besteht, verifiziert der Server, ob der Client die Berechtigungen für die jeweils ausgeführten Abfragen besitzt (z.B., ob es dem Client erlaubt ist, eine SELECT-Anweisung auszuführen, die auf die Country-Tabelle in der Datenbank world zugreift). Wir behandeln diese Themen detailliert in Kapitel 12.
Optimierung und Ausführung MySQL analysiert Abfragen, um eine interne Struktur zu erzeugen (den Parse- oder Syntaxbaum), und führt dann eine Reihe von Optimierungen durch. Dazu können das Umschreiben der Abfrage, das Feststellen der Reihenfolge, in der die Tabellen gelesen werden, das Auswählen der zu verwendenden Indizes usw. gehören. Über spezielle Schlüsselwörter in der Abfrage können Sie Hinweise an den Optimierer übergeben, die die Entscheidungsfindung beeinflussen. Darüber hinaus können Sie den Server auffordern, verschiedene Aspekte der Optimierung zu erklären. Auf diese Weise erfahren Sie, welche Entscheidungen der Server trifft. Sie erhalten also einen Anhaltspunkt zum Überarbeiten von Abfragen, Schemata und Einstellungen, damit Sie alles so effizient wie möglich gestalten können. Auf den Optimierer gehen wir in Kapitel 4 ausführlicher ein. Dem Optimierer ist es im Prinzip egal, welche Storage-Engine eine bestimmte Tabelle verwendet, die Storage-Engine hingegen beeinflusst, wie der Server die Abfrage optimiert. Der Optimierer fragt die Storage-Engine nach einigen ihrer Fähigkeiten und den Kosten für bestimmte Operationen sowie nach Statistiken über die Tabellendaten. Einige Storage-Engines unterstützen z.B. Indextypen, die für bestimmte Abfragen hilfreich sein können. Mehr Informationen über Indizierung und Schema-Optimierung erhalten Sie in Kapitel 3. Bevor allerdings die Abfrage geparst wird, schaut der Server im Abfrage-Cache nach, der nur SELECT-Anweisungen sowie deren Ergebnissätze speichern kann. Wenn jemand eine Abfrage ausführt, die identisch ist mit einer, die sich bereits im Cache befindet, dann muss der Server diese Abfrage nicht parsen, optimieren oder ausführen – er kann einfach den gespeicherten Ergebnissatz zurückliefern! Wir besprechen den Abfrage-Cache ausführlich in »Der MySQL-Abfrage-Cache« auf Seite 220. 2 MySQL AB plant, in künftigen Versionen des Servers Verbindungen von Threads zu trennen.
Die logische Architektur von MySQL | 3
Nebenläufigkeitskontrolle Immer wenn zu einem Zeitpunkt mehr als eine Abfrage Daten ändern muss, tritt das Problem der Nebenläufigkeitskontrolle (Concurrency Control) auf. Für unsere Zwecke in diesem Kapitel muss MySQL auf zwei Ebenen aktiv werden: auf der Serverebene und auf der Ebene der Storage-Engine. Dem großen Thema der Nebenläufigkeitskontrolle widmet sich ein Großteil der theoretischen Literatur. Dieses Buch allerdings befasst sich nicht mit der Theorie oder gar mit den Interna von MySQL. Daher geben wir Ihnen nur einen vereinfachten Überblick darüber, wie MySQL mit nebenläufigen Lese- und Schreibvorgängen umgeht, damit Sie die nötigen Informationen für den Rest dieses Kapitels haben. Wir benutzen eine Mailbox auf einem Unix-System als Beispiel. Das klassische mboxDateiformat ist sehr einfach. Alle Nachrichten in einer mbox-Mailbox werden eine nach der anderen aneinandergefügt. Das macht es sehr einfach, E-Mail-Nachrichten zu lesen und zu verarbeiten. Außerdem vereinfacht es die Auslieferung der E-Mails: Eine neue Nachricht wird einfach an das Ende der Datei angehängt. Was geschieht jedoch, wenn zwei Prozesse versuchen, etwas zur gleichen Zeit an die gleiche Mailbox auszuliefern? Natürlich kann das die Mailbox beschädigen und zwei ineinander vermischte Nachrichten am Ende der Mailbox-Datei hinterlassen. Anständige Systeme zur Mail-Auslieferung setzen Sperren (Locks) ein, um eine Beschädigung zu vermeiden. Versucht ein Client eine zweite Auslieferung, während die Mailbox gesperrt ist, muss er warten, bis er den Lock erhalten hat, bevor er die Nachricht zustellen kann. Dieses Schema funktioniert in der Praxis recht gut, bietet aber keine Unterstützung für Nebenläufigkeit. Da zu einem Zeitpunkt nur ein einziger Prozess die Mailbox ändern darf, wirft dieser Ansatz bei einer stark genutzten Mailbox Probleme auf.
Lese/Schreib-Locks Das Lesen aus der Mailbox ist nicht ganz so problematisch. Es gibt keine Schwierigkeiten, wenn mehrere Clients gleichzeitig die gleiche Mailbox auslesen. Da sie keine Änderungen vornehmen, kann eigentlich auch nichts schiefgehen. Was passiert aber, wenn jemand versucht, Nachricht Nummer 25 zu löschen, während andere Programme die Mailbox auslesen? Es kommt drauf an. Ein Leser könnte eine beschädigte oder inkonsistente Ansicht der Mailbox erhalten. Um sicherzugehen, verlangt sogar das Lesen aus einer Mailbox besondere Sorgfalt. Wenn Sie sich die Mailbox als Datenbanktabelle und jede Nachricht als eine Zeile vorstellen, dann werden Sie leicht merken, dass das Problem in diesem Kontext das gleiche ist. In vielerlei Hinsicht ist eine Mailbox nur eine einfache Datenbanktabelle. Das Modifizieren von Zeilen (bzw. Datensätzen) in einer Datenbanktabelle ist dem Löschen oder Ändern von Nachrichten in einer Mailbox-Datei sehr ähnlich. Die Lösung dieses klassischen Problems der Nebenläufigkeitskontrolle ist recht einfach. Systeme, die einen nebenläufigen, d.h. parallel erfolgenden Lese-/Schreibzugriff erlau-
4 | Kapitel 1: Die MySQL-Architektur
ben, implementieren typischerweise ein Locking-System, das zwei Arten von Sperren unterstützt. Diese Sperren oder Locks sind üblicherweise als Shared Locks und Exklusive Locks oder als Lese-Locks und Schreib-Locks bekannt. Ohne uns um die eigentliche Locking-Technik zu kümmern, können wir das Konzept folgendermaßen beschreiben. Die Lese-Locks (Read Locks) für eine Ressource werden gemeinsam genutzt (engl. Shared): Viele Clients können die Ressource gleichzeitig lesen und stören einander nicht. Schreib-Locks dagegen sind exklusiv – d.h., sie blockieren sowohl Lese-Locks als auch andere Schreib-Locks –, da die einzig sichere Methode darin besteht, zu einem Zeitpunkt nur einen einzigen Client auf die Ressource schreiben zu lassen und alle Lesevorgänge zu verhindern, wenn ein Client schreibt. In der Datenbankwelt kommt das Locking ständig vor: MySQL muss verhindern, dass ein Client einen Teil der Daten liest, während ihn ein anderer Client ändert. Es führt dieses Lock-Management intern auf eine Art und Weise aus, die größtenteils transparent ist.
Locking-Granularität Eine Möglichkeit, die Nebenläufigkeit einer gemeinsam genutzten Ressource zu verbessern, besteht darin, bei der Wahl dessen, was gesperrt wird, selektiver zu sein. Anstatt die gesamte Ressource zu sperren, könnten Sie nur den Teil sperren, der die zu ändernden Daten enthält. Oder noch besser: Sperren Sie genau den Teil der Daten, der geändert werden soll. Indem Sie die Menge der zu sperrenden Daten einschränken, können mehr Änderungen gleichzeitig erfolgen – solange sie sich untereinander nicht überschneiden. Problematisch ist allerdings, dass die Locks Ressourcen beanspruchen. Jede Lock-Operation – das Erstellen eines Locks, die Prüfung, ob ein Lock frei ist, das Freigeben eines Locks usw. – erfordert einen gewissen Aufwand. Wenn das System zu viel Zeit damit verbringt, die Locks zu verwalten, anstatt Daten zu speichern und abzurufen, leidet möglicherweise die Performance. Eine Locking-Strategie stellt immer einen Kompromiss aus Locking-Overhead und Datensicherheit dar; dieser Kompromiss beeinflusst schließlich die Performance. Die meisten kommerziellen Datenbankserver lassen Ihnen kaum eine Wahl: Sie können für Ihre Tabellen das sogenannte Row-Level Locking einsetzen, also das Locking auf Datensatzebene, bei dem Ihnen eine Vielzahl von oftmals komplexen Methoden zur Verfügung steht, um eine gute Performance mit vielen Locks zu erreichen. Bei MySQL haben Sie dagegen die Wahl. Seine Storage-Engines können eigene LockingRichtlinien und -Granularitäten implementieren. Die Locking-Verwaltung bildet eine wichtige Entscheidung beim Entwurf der Storage-Engine; das Festlegen der Granularität auf einer bestimmten Stufe kann für verschiedene Anwendungszwecke eine bessere Performance gewährleisten, die Engine jedoch für andere Fälle weniger gut geeignet erscheinen lassen. Da MySQL mehrere Storage-Engines bietet, ist es nicht nötig, sich auf eine einzige, allumfassende Lösung zu beschränken. Schauen wir uns die beiden wichtigsten Locking-Strategien an.
Nebenläufigkeitskontrolle | 5
Tabellen-Locks Die grundlegendste und mit dem geringsten Overhead verbundene Locking-Strategie in MySQL ist der Tabellen-Lock. Er entspricht dem bereits beschriebenen Mailbox-Locking: Er sperrt die gesamte Tabelle. Möchte ein Client etwas in die Tabelle schreiben (einfügen, löschen, aktualisieren usw.), beschafft er sich einen Schreib-Lock, der alle anderen Leseund Schreiboperationen in Schach hält. Wenn niemand schreibt, können lesende Prozesse Lese-Locks anfordern, die anderen Lese-Locks nicht in die Quere kommen. Tabellen-Locks bieten Variationen, um unter bestimmten Bedingungen eine gute Performance zu gewährleisten. Beispielsweise erlauben READ LOCAL-Tabellen-Locks einige Arten von nebenläufigen, d.h. parallel erfolgenden Schreiboperationen. Schreib-Locks besitzen außerdem eine höhere Priorität als Lese-Locks, so dass die Anforderung eines SchreibLocks an den Anfang der Locking-Warteschlange rückt, auch wenn sich bereits lesende Prozesse in der Warteschlange befinden (Schreib-Locks können in der Warteschlange an Lese-Locks vorbeiziehen, Lese-Locks dagegen können Schreib-Locks nicht überholen). Storage-Engines können zwar ihre eigenen Locks verwalten, dennoch verwendet auch MySQL eine Vielzahl von Locks für verschiedene Zwecke, bei denen es sich prinzipiell um Tabellen-Locks handelt. So setzt etwa der Server ungeachtet der Storage-Engine einen Tabellen-Lock für Anweisungen wie ALTER TABLE ein.
Row-Locks Die Form des Lockings, die die größtmögliche Nebenläufigkeit ermöglicht (und den meisten Overhead mitschleppt) ist das zeilenorientierte oder Row-Locking. Row-Locking gibt es unter anderem in den InnoDB- und Falcon-Storage-Engines. Row-Locks werden in der Storage-Engine implementiert, nicht im Server (werfen Sie einfach noch einmal einen Blick auf die Darstellung der logischen Architektur). Der Server ist völlig ahnungslos, was Locks betrifft, die in den Storage-Engines implementiert sind. Wie Sie später noch erfahren werden, implementieren die Storage-Engines das Locking alle auf ihre eigene Weise.
Transaktionen Es ist kaum möglich, sich mit den erweiterten Funktionen eines Datenbanksystems zu befassen, ohne auf Transaktionen zu stoßen. Eine Transaktion ist eine Gruppe von SQLAbfragen, die als atomar betrachtet werden, d.h. als zusammengehörende Einheit. Entweder wird die gesamte Gruppe der Abfragen von der Datenbank-Engine auf die Datenbank angewandt oder keine (z.B. aufgrund eines Absturzes oder aus einem anderen Grund). Hier gilt: alles oder nichts! Nur ein kleiner Teil dieses Abschnitts ist MySQL-spezifisch. Wenn Sie bereits mit ACIDTransaktionen vertraut sind, können Sie direkt mit »Transaktionen bei MySQL« auf Seite 11 fortfahren. Eine Bankanwendung ist das klassische Beispiel dafür, weshalb Transaktionen notwendig sind. Stellen Sie sich vor, die Datenbank der Bank würde aus zwei Tabellen bestehen:
6 | Kapitel 1: Die MySQL-Architektur
Girokonto und Sparkonto. Um 200 € von Karlas Girokonto auf ihr Sparkonto zu überwei-
sen, sind mindestens drei Schritte notwendig: 1. Sicherstellen, dass ihr Guthaben auf dem Girokonto mehr als 200 € aufweist 2. 200 € vom Girokonto abziehen 3. 200 € dem Sparkonto gutschreiben
Die gesamte Operation muss in einer Transaktion zusammengefasst werden, damit sie als Ganzes zurückgenommen werden kann, falls einer der Schritte fehlschlägt. Eine Transaktion wird mit der Anweisung START TRANSACTION gestartet und dann mit COMMIT bestätigt und gespeichert oder mit ROLLBACK zurückgenommen. Der SQL-Code für die Beispieltransaktion könnte so aussehen: 1 2 3 4 5
START TRANSACTION; SELECT balance FROM checking WHERE customer_id = 10233276; UPDATE checking SET balance = balance - 200.00 WHERE customer_id = 10233276; UPDATE savings SET balance = balance + 200.00 WHERE customer_id = 10233276; COMMIT;
Transaktionen allein reichen aber nicht aus. Was passiert, wenn der Datenbankserver abstürzt, während er gerade Zeile 4 ausführt? Wer weiß? Die Kundin hat wahrscheinlich gerade 200 € verloren. Und was passiert, wenn ein anderer Prozess zwischen den Zeilen 3 und 4 einfach das ganze Girokonto löscht? Die Bank hätte der Kundin einen Kredit von 200 € gewährt, ohne es überhaupt zu wissen. Transaktionen reichen nicht aus, wenn das System nicht den sogenannten ACID-Test besteht. ACID ist ein Akronym für »Atomicity, Consistency, Isolation, Durability«, also Atomarität, Konsistenz, Isolation, Dauerhaftigkeit, vier eng miteinander verknüpften Kriterien, die ein gut funktionierendes Transaktionsverarbeitungssystem erfüllen muss: Atomicity (Atomarität) Eine Transaktion muss als eine einzelne, nicht teilbare Arbeitseinheit ausgeführt werden: Entweder wird die gesamte Transaktion angewandt, oder sie wird komplett zurückgenommen. Wenn Transaktionen atomar sind, dann gibt es keine teilweise abgeschlossene Transaktion. Das Prinzip heißt: alles oder nichts. Consistency (Konsistenz) Die Datenbank muss sich immer von einem konsistenten Zustand in den nächsten bewegen. In unserem Beispiel sorgt die Konsistenz dafür, dass ein Absturz zwischen den Zeilen 3 und 4 nicht dazu führt, dass 200 € vom Girokonto verschwinden. Da die Transaktion niemals bestätigt wird (COMMIT), spiegelt sich keine der an der Datenbank durchgeführten Änderungen in der Datenbank wider. Isolation Die Ergebnisse einer Transaktion sind üblicherweise für andere Transaktionen unsichtbar, bis die Transaktion abgeschlossen ist. Das stellt in unserem Fall sicher, dass bei der Erstellung einer Kontoübersicht nach Zeile 3, aber vor Zeile 4 die 200 € immer noch auf dem Girokonto zu sehen sind. Wenn wir die verschiedenen Isolationsebenen besprechen, werden Sie verstehen, weshalb wir üblicherweise sagen.
Transaktionen | 7
Durability (Dauerhaftigkeit) Einmal mit COMMIT bestätigt, werden die Ergebnisse der Transaktion dauerhaft gespeichert. Das bedeutet, dass die Änderungen in einer Art festgehalten werden müssen, die dafür sorgt, dass die Daten bei einem Systemabsturz nicht verlorengehen. Das Konzept der Dauerhaftigkeit ist allerdings etwas unscharf, da es tatsächlich viele Stufen gibt. Manche Dauerhaftigkeitsstrategien bieten eine stärkere Sicherheitsgarantie als andere, und nichts ist wirklich hundertprozentig von Dauer. Wir werden später darauf eingehen, was Dauerhaftigkeit in MySQL wirklich bedeutet. Freuen Sie sich speziell auf »InnoDB-Ein-/Ausgabe-Tuning« auf Seite 306. ACID-Transaktionen sorgen dafür, dass die Banken Ihr Geld nicht verlieren. Es ist im Allgemeinen ausgesprochen schwierig, wenn nicht gar unmöglich, dies mit der Anwendungslogik zu erreichen. Ein ACID-konformer Datenbankserver muss alle möglichen komplizierten Dinge tun, die Sie möglicherweise gar nicht mitbekommen, um ACIDGarantien zu gewährleisten. Genau wie bei der erhöhten Locking-Granularität besteht der Nachteil dieser zusätzlichen Sicherheit darin, dass der Datenbankserver mehr Arbeit erledigen muss. Das bedeutet auch, dass ein Datenbankserver mit ACID-Transaktionen im Allgemeinen mehr CPULeistung, Speicher und Plattenplatz benötigt als ohne. Wie wir bereits mehrfach ausgeführt haben, spielt hier die Storage-Engine-Architektur von MySQL ihre Vorteile aus. Sie können selbst entscheiden, ob Ihre Anwendung Transaktionen benötigt. Wenn Sie sie nicht brauchen, können Sie bei einigen Arten von Abfragen eine höhere Leistung erreichen, wenn Sie eine Storage-Engine verwenden, die keine Transaktionen bietet. Sie könnten sogar LOCK TABLES einsetzen, um auch ohne Transaktionen die notwendige Sicherheit zu erhalten. Es liegt ganz bei Ihnen.
Isolationsebenen Isolation ist komplexer, als es auf den ersten Blick erscheinen mag. Der SQL-Standard definiert vier Isolationsebenen mit speziellen Regeln dafür, welche Änderungen innerhalb und außerhalb einer Transaktion sichtbar sind oder nicht. Niedrigere Isolationsebenen erlauben typischerweise eine stärkere Nebenläufigkeit und bringen einen geringeren Overhead mit sich. Jede Storage-Engine implementiert die Isolationsebenen etwas anders, und möglicherweise entspricht die Umsetzung nicht dem, was Sie erwarten würden, wenn Sie mit einem anderen Datenbankprodukt vertraut sind (wir werden deshalb in diesem Abschnitt nicht auf jedes einzelne Detail eingehen). Lesen Sie einfach das Handbuch der Storage-Engine, für die Sie sich letztendlich entschieden haben.
8 | Kapitel 1: Die MySQL-Architektur
Schauen wir uns die vier Isolationsebenen an: READ UNCOMMITTED
Auf der Isolationsebene READ UNCOMMITTED können Transaktionen die Ergebnisse noch nicht bestätigter Transaktionen sehen. Auf dieser Ebene können sehr viele Probleme auftreten, wenn Sie nicht ganz genau wissen, was Sie tun, und keinen guten Grund haben, es zu tun. In der Praxis wird diese Ebene selten genutzt, da ihre Performance kaum besser ist als die der anderen Ebenen, die wiederum viele Vorteile bieten. Das Lesen unbestätigter Daten wird auch als Dirty Read bezeichnet. READ COMMITTED
Die Standardisolationsebene der meisten Datenbanksysteme (aber nicht von MySQL!) ist READ COMMITTED. Sie entspricht der einfachen Definition der Isolation, die wir vorhin verwendet haben: Eine Transaktion sieht nur die Ergebnisse von Transaktionen, die bereits bestätigt waren, als sie begann. Ihre Änderungen wiederum werden erst sichtbar, nachdem sie bestätigt wurde. Auf dieser Ebene ist immer noch ein sogenannter Nonrepeatable Read (eine nicht wiederholbare Leseoperation) erlaubt. Dies bedeutet, dass Sie eine Anweisung zweimal ausführen können und unterschiedliche Daten zu sehen bekommen. REPEATABLE READ REPEATABLE READ löst die Probleme, die READ UNCOMMITTED zulässt. Diese Ebene garan-
tiert, dass alle Zeilen, die eine Transaktion liest, bei nachfolgenden Lesevorgängen innerhalb der gleichen Transaktion »gleich aussehen«. Theoretisch kann aber immer noch ein anderes schwerwiegendes Problem auftreten, nämlich das der PhantomReads. Vereinfacht gesagt, kann ein Phantom-Read auftreten, wenn Sie einen Bereich von Zeilen auswählen, eine andere Transaktion eine neue Zeile in diesen Bereich einfügt und Sie diesen Bereich erneut auswählen. Sie sehen dann diese neue »Phantom«-Zeile. InnoDB und Falcon lösen das Phantom-Read-Problem mithilfe der Multi-Version Concurrency Control, die wir weiter hinten in diesem Kapitel erklären. REPEATABLE READ ist die Standardisolationsebene von MySQL. Die Storage-Engines
InnoDB und Falcon respektieren diese Einstellung; Sie lernen in Kapitel 6, wie Sie sie ändern. Einige andere Engines beachten sie ebenfalls, das hängt aber von der Engine ab. SERIALIZABLE
Die höchste Isolationsebene, SERIALIZABLE, löst das Phantom-Read-Problem, indem die Transaktionen so angeordnet werden, dass sie sich nicht stören können. SERIALIZABLE setzt quasi auf jede Zeile, die es liest, eine Sperre. Auf dieser Ebene kann es zu vielen Timeouts und Kämpfen um einen Lock kommen. Wir kennen kaum Leute, die diese Isolationsebene benutzen, allerdings könnten die Anforderungen Ihrer Anwendung es notwendig machen, die verringerte Performance in Kauf zu nehmen, um die damit verbundene Datenstabilität zu erreichen. Tabelle 1-1 fasst die verschiedenen Isolationsebenen und die mit ihnen verbundenen Nachteile zusammen.
Transaktionen | 9
Tabelle 1-1: ANSI SQL-Isolationsebenen Isolationsebene
Dirty Reads möglich
Nonrepeatable Reads möglich
Phantom-Reads möglich
Locking-Reads
READ UNCOMMITTED
Ja
Ja
Ja
Nein
READ COMMITTED
Nein
Ja
Ja
Nein
REPEATABLE READ
Nein
Nein
Ja
Nein
SERIALIZABLE
Nein
Nein
Nein
Ja
Deadlocks Ein Deadlock tritt auf, wenn zwei oder mehr Transaktionen wechselseitig Locks auf denselben Ressourcen anfordern und halten und dadurch einen Kreis von Abhängigkeiten schaffen. Es kommt zu Deadlocks, wenn Transaktionen versuchen, Ressourcen in unterschiedlicher Reihenfolge zu sperren. Sie können auftreten, wenn mehrere Transaktionen die gleichen Ressourcen sperren. Nehmen wir als Beispiel diese beiden Transaktionen, die über die StockPrice-Tabelle laufen sollen: Transaktion #1 START TRANSACTION; UPDATE StockPrice SET close = 45.50 WHERE stock_id = 4 and date = '2002-05-01'; UPDATE StockPrice SET close = 19.80 WHERE stock_id = 3 and date = '2002-05-02'; COMMIT;
Transaktion #2 START TRANSACTION; UPDATE StockPrice SET high UPDATE StockPrice SET high COMMIT;
= 20.12 WHERE stock_id = 3 and date = '2002-05-02'; = 47.20 WHERE stock_id = 4 and date = '2002-05-01';
Wenn Sie Pech haben, führt jede Transaktion die erste Anweisung aus und aktualisiert eine Datenzeile, wodurch diese in dem Prozess gesperrt wird. Beide Transaktionen versuchen dann, ihre zweite Zeile zu aktualisieren, wobei sie dann feststellen, dass diese bereits gesperrt ist. Die beiden Transaktionen warten nun bis in alle Ewigkeit darauf, dass die jeweils andere fertig wird – es sei denn, jemand schreitet ein und löst diesen Deadlock auf. Um dieses Problem zu lösen, implementieren Datenbanksysteme verschiedene Formen von Deadlock-Erkennung und Timeouts. Die schlaueren Systeme, wie etwa die InnoDBStorage-Engine, erkennen zyklische Abhängigkeiten und geben einen Fehler zurück. Das ist in der Tat sehr gut, da sich Deadlocks ansonsten in ausgesprochen langsam ablaufenden Abfragen äußern würden. Andere geben nach einer gewissen Zeit auf, wenn sie keinen Lock erhalten haben, was wiederum nicht so gut ist. Der Umgang von InnoDB mit Deadlocks sieht momentan so aus, dass es diejenige Transaktion rückgängig macht, die die wenigsten exklusiven Row-Locks besitzt (ein ungefähres Maß, für das es am einfachsten ist, es rückgängig zu machen).
10 |
Kapitel 1: Die MySQL-Architektur
Das Verhalten und die Reihenfolge von Locks hängen von der jeweiligen Storage-Engine ab. Einige Storage-Engines landen möglicherweise bei einer bestimmten Abfolge von Anweisungen in einem Deadlock, während andere dies nicht tun. Deadlocks haben eine Doppelnatur: Manche sind aufgrund echter Datenkonflikte unvermeidlich, während andere aufgrund der Funktionsweise einer Storage-Engine entstehen. Deadlocks können nicht unterbrochen werden, ohne eine der Transaktionen, entweder teilweise oder vollständig, zu widerrufen. Sie gehören zu Transaktionssystemen einfach dazu. Ihre Anwendungen müssen daher in der Lage sein, mit ihnen zurechtzukommen. Viele Anwendungen können einfach ihre Transaktionen wiederholen.
Transaktions-Log Mit einer Protokollierung der Transaktionen (Transaktions-Logging) können Transaktionen effizienter gestaltet werden. Anstatt die Tabellen auf der Festplatte nach jeder Änderung zu aktualisieren, kann die Storage-Engine die im Speicher befindliche Kopie der Daten ändern. Das geht sehr schnell. Die Storage-Engine schreibt dann einen Eintrag für die Änderung in das Transaktions-Log, das sich auf der Festplatte befindet und daher dauerhaft ist. Auch dies ist eine relativ schnelle Operation, da das Anhängen von LogEreignissen anstelle der zufälligen Ein-/Ausgabe an vielen Stellen nur eine sequenzielle Ein-/Ausgabe auf einem sehr kleinen Bereich der Festplatte umfasst. Zu einem späteren Zeitpunkt kann ein Prozess dann die Tabelle auf der Festplatte aktualisieren. Die meisten Storage-Engines, die diese (auch als Write-Ahead Logging bezeichnete) Technik einsetzen, müssen daher Änderungen zweimal auf die Festplatte schreiben.3 Kommt es zu einem Absturz, nachdem die Aktualisierung in das Transaktions-Log geschrieben wurde, aber bevor die Änderungen an den Daten selbst vorgenommen wurden, kann die Storage-Engine die Änderungen nach einem Neustart wiederherstellen. Die Wiederherstellungsmethode hängt von der jeweiligen Storage-Engine ab.
Transaktionen bei MySQL MySQL AB stellt drei transaktionsfähige Storage-Engines bereit: InnoDB, NDB Cluster und Falcon. Es gibt außerdem verschiedene Engines von Drittanbietern; die momentan bekanntesten Engines sind solidDB und PBXT. Im nächsten Abschnitt stellen wir spezielle Eigenschaften der einzelnen Engines vor.
AUTOCOMMIT MySQL arbeitet per Voreinstellung im AUTOCOMMIT-Modus. Das bedeutet, dass jede Abfrage als separate Transaktion ausgeführt wird, solange Sie nicht ausdrücklich eine Transaktion begonnen haben. Sie können AUTOCOMMIT für die aktuelle Verbindung aktivieren oder deaktivieren, indem Sie eine Variable setzen: 3 Die PBXT-Storage-Engine vermeidet clevererweise das Write-Ahead Logging.
Transaktionen |
11
mysql> SHOW VARIABLES LIKE 'AUTOCOMMIT'; +---------------+-------+ | Variable_name | Value | +---------------+-------+ | autocommit | ON | +---------------+-------+ 1 row in set (0.00 sec) mysql> SET AUTOCOMMIT = 1;
Die Werte 1 und ON sind äquivalent, genau wie 0 und OFF. Wenn Sie mit AUTOCOMMIT=0 arbeiten, sind Sie immer in einer Transaktion, bis Sie COMMIT oder ROLLBACK ausführen. MySQL startet dann sofort eine neue Transaktion. Das Ändern des Wertes von AUTOCOMMIT hat keine Wirkung auf nichttransaktionsfähige Tabellen wie MyISAM- oder Memory-Tabellen, die prinzipiell immer im AUTOCOMMIT-Modus arbeiten. Werden bestimmte Befehle während einer offenen Transaktion aufgerufen, dann veranlassen sie MySQL, die Transaktion zu bestätigen, bevor sie ausgeführt werden. Bei diesen Befehlen handelt es sich typischerweise um DDL-Befehle (Data Definition Language), die wesentliche Änderungen verursachen können, wie etwa ALTER TABLE. Aber auch LOCK TABLES und einige andere Anweisungen haben diese Wirkung. In der Dokumentation Ihrer Version finden Sie eine vollständige Liste der Befehle, die automatisch eine Transaktion bestätigen. MySQL erlaubt es Ihnen, mit dem Befehl SET TRANSACTION ISOLATION LEVEL die Isolationsebene festzulegen, die wirksam wird, wenn die nächste Transaktion beginnt. Sie können die Isolationsebene für den gesamten Server in der Konfigurationsdatei festlegen (siehe Kapitel 6) oder sich auf die aktuelle Sitzung beschränken: mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
MySQL erkennt alle vier Standard-ANSI-Isolationsebenen, InnoDB unterstützt sie alle. Andere Storage-Engines bieten unterschiedliche Unterstützung für die verschiedenen Isolationsebenen.
Storage-Engines in Transaktionen mischen Bei MySQL werden die Transaktionen nicht vom Server verwaltet; stattdessen implementieren die zugrunde liegenden Storage-Engines die Transaktionen selbst. Aus diesem Grund ist es nicht möglich, unterschiedliche Engines in einer einzigen Transaktion zu mischen. Bei MySQL AB arbeitet man daran, den Server um eine Transaktionsverwaltung auf höherer Ebene zu erweitern, wodurch es möglich werden wird, transaktionsfähige Tabellen in einer Transaktion zu mischen und zu vergleichen. Bis es so weit ist, müssen Sie vorsichtig sein. Wenn Sie transaktionsfähige und nichttransaktionsfähige Tabellen (z.B. InnoDB- und MyISAM-Tabellen) in einer Transaktion mischen, funktioniert die Transaktion (wenn alles gut geht). Wird jedoch ein Rollback erforderlich, dann können die Änderungen an der nichttransaktionsfähigen Tabelle nicht zurückgenommen werden. Die Datenbank verbleibt in einem inkonsistenten Zustand, der nur schwer wieder ausgeglichen werden
12 |
Kapitel 1: Die MySQL-Architektur
kann und die ganze Idee einer Transaktion ad absurdum führt. Daher ist es enorm wichtig, die richtige Storage-Engine für eine Tabelle zu wählen. Normalerweise warnt MySQL Sie nicht, wenn Sie transaktionsfähige Operationen auf einer nichttransaktionsfähigen Tabelle durchführen. Gelegentlich generiert die Zurücknahme einer Transaktion die Warnung »Some nontransactional changed tables couldn’t be rolled back«, meist allerdings gibt es kein Anzeichen dafür, dass Sie mit nichttransaktionsfähigen Tabellen arbeiten.
Implizites und explizites Locking InnoDB verwendet ein zweiphasiges Locking-Protokoll. Es kann sich jederzeit während einer Transaktion Locks beschaffen, gibt sie aber erst bei einem COMMIT oder ROLLBACK wieder frei. Alle Locks werden gleichzeitig freigegeben. Die früher beschriebenen LockingMechanismen sind alle implizit. InnoDB behandelt die Locks automatisch entsprechend Ihrer Isolationsebene. Allerdings unterstützt InnoDB auch explizites Locking, das vom SQL-Standard nicht einmal erwähnt wird: • SELECT ... LOCK IN SHARE MODE • SELECT ... FOR UPDATE MySQL unterstützt auch die Befehle LOCK TABLES und UNLOCK TABLES, die im Server und nicht in den Storage-Engines implementiert sind. Es gibt für sie Anwendungsfälle, allerdings stellen sie keinen Ersatz für Transaktionen dar. Wenn Sie Transaktionen benötigen, dann verwenden Sie eine transaktionsfähige Storage-Engine. Wir haben es oft mit Anwendungen zu tun, die von MyISAM nach InnoDB konvertiert wurden, aber weiterhin LOCK TABLES benutzen. Dies ist aufgrund des Row-Level-Locking nicht mehr notwendig und kann schwerwiegende Performance-Probleme verursachen. Die Interaktion zwischen LOCK TABLES und Transaktionen ist komplex, und es kann in manchen Serverversionen zu unerwarteten Verhaltensweisen kommen. Wir empfehlen daher, dass Sie – egal, welche Storage-Engine Sie verwenden – von der Verwendung von LOCK TABLES absehen, es sei denn, Sie sind in einer Transaktion, und AUTOCOMMIT ist deaktiviert.
Multi-Version Concurrency Control Die meisten der transaktionsfähigen Storage-Engines von MySQL, wie etwa InnoDB, Falcon und PBXT, verwenden keinen einfachen Row-Locking-Mechanismus, sondern benutzen Row-Level-Locking zusammen mit einer Technik zur Erhöhung der Nebenläufigkeit namens Multi-Version Concurrency Control (MVCC). MVCC ist nicht auf MySQL beschränkt, auch Oracle, PostgreSQL und einige andere Datenbanksysteme setzen es ein.
Multi-Version Concurrency Control |
13
Sie können sich MVCC als eine neue Variante des Row-Level-Lockings vorstellen. Sie müssen in vielen Fällen überhaupt nicht sperren und haben einen geringeren Overhead. Je nach seiner Implementierung erlaubt es nichtsperrende Leseoperationen und sperrt während der Schreiboperationen nur die notwendigen Datensätze. MVCC behält einen Schnappschuss der Daten von einem ganz bestimmten Zeitpunkt. Das bedeutet, dass Transaktionen eine konsistente Sicht der Daten sehen, unabhängig davon, wie lange ihre Ausführung dauert. Es bedeutet aber auch, dass unterschiedliche Transaktionen zur gleichen Zeit unterschiedliche Daten in den gleichen Tabellen sehen können! Wenn Sie das noch nie zuvor erlebt haben, mag es zunächst verwirrend sein, mit der Zeit aber werden Sie es immer besser verstehen. Jede Storage-Engine implementiert MVCC anders. Zu den Varianten gehören optimistische und pessimistische Concurrency Control. Wir werden eine Möglichkeit der Funktion von MVCC anhand einer vereinfachten Version des Verhaltens von InnoDB erläutern. InnoDB implementiert MVCC, indem es für jede Zeile zwei zusätzliche verborgene Werte speichert, die aufzeichnen, wann diese Zeile erzeugt wurde und wann sie verfällt (oder gelöscht wurde). Anstatt die tatsächlichen Zeiten festzuhalten, an denen diese Ereignisse eingetreten sind, speichert die Zeile die Systemversionsnummer zum Zeitpunkt des Ereignisses. Dabei handelt es sich um eine Zahl, die immer dann erhöht wird, wenn eine Transaktion beginnt. Jede Transaktion besitzt ab dem Zeitpunkt, zu dem sie begann, einen eigenen Datensatz mit der aktuellen Systemversion. Alle Abfragen müssen die Versionsnummern der Zeilen anhand der Version der Transaktion überprüfen. Wir wollen uns anschauen, wie das bei bestimmten Operationen funktioniert, wenn die Isolationsebene auf REPEATABLE READ gesetzt ist: SELECT
InnoDB muss jede Zeile untersuchen, um sicherzustellen, dass sie zwei Kriterien erfüllt: • InnoDB muss eine Version der Zeile finden, die mindestens so alt ist wie die Transaktion (d.h., ihre Version muss kleiner oder gleich der Version der Transaktion sein). Dies stellt sicher, dass die Zeile entweder bereits existierte, als die Transaktion begann, oder dass die Transaktion die Zeile erzeugte bzw. veränderte. • Die Löschversionsnummer (Deletion-ID) der Zeile muss undefiniert oder größer sein als die Version der Transaktion. Dies stellt sicher, dass die Zeile nicht gelöscht war, bevor die Transaktion begann. Zeilen, die beide Tests bestehen, können als Ergebnis der Abfrage zurückgeliefert werden. INSERT
InnoDB zeichnet die aktuelle Systemversionsnummer in der neuen Zeile auf. DELETE
InnoDB zeichnet die aktuelle Systemversionsnummer als Deletion-ID der Zeile auf.
14 |
Kapitel 1: Die MySQL-Architektur
UPDATE
InnoDB schreibt eine neue Kopie der Zeile und verwendet dabei die Systemversionsnummer für die Version der neuen Zeile. Außerdem schreibt es die Systemversionsnummer als Deletion-ID der alten Zeile. Das Ergebnis dieses zusätzlichen Aufwands besteht darin, dass die meisten lesenden Abfragen niemals Locks anfordern. Sie lesen die Daten ganz einfach so schnell sie können, wobei sie aber nur Zeilen auswählen, die den Kriterien entsprechen. Nachteilig ist allerdings, dass die Storage-Engine in den einzelnen Zeilen mehr Daten speichern muss, mehr Aufwand beim Untersuchen der Zeilen hat und mehr Verwaltungsoperationen durchführen muss. MVCC funktioniert nur mit den Isolationsebenen REPEATABLE READ und READ COMMITTED. READ UNCOMMITTED ist nicht MVCC-kompatibel, da die Abfragen nicht die Zeilenversion lesen, die ihrer Transaktionsversion entspricht; sie lesen einfach immer die neueste Version. SERIALIZABLE ist nicht MVCC-kompatibel, weil Leseoperationen jede Zeile sperren, die sie zurückliefern. In Tabelle 1-2 sind die verschiedenen Locking-Modelle und Concurrency-Ebenen in MySQL noch einmal zusammengefasst. Tabelle 1-2: Locking-Modelle und Concurrency in MySQL bei der Standardisolationsebene Locking-Strategie
Concurrency
Overhead
Engines
Tabellenorientiert
Niedrigste
Niedrigster
MyISAM, Merge, Memory
Zeilenorientiert
Hoch
Hoch
NDB Cluster
Zeilenorientiert mit MVCC
Höchste
Höchster
InnoDB, Falcon, PBXT, solidDB
Die Storage-Engines von MySQL In diesem Abschnitt erhalten Sie einen Überblick über die Storage-Engines von MySQL. Wir werden hier nicht allzu sehr ins Detail gehen, da wir die Storage-Engines und ihre speziellen Verhaltensweisen im Laufe des Buches noch genauer erläutern. Allerdings ist selbst dieses Buch keine komplette Dokumentation; Sie müssen daher unbedingt die MySQL-Handbücher für die Storage-Engines lesen, für die Sie sich entschieden haben. MySQL bietet darüber hinaus Foren für die einzelnen Storage-Engines, in denen Sie oft auch Links auf weiterführende Informationen und interessante Einsatzgebiete finden. Falls Sie die Engines nur grob miteinander vergleichen wollen, können Sie sich gleich zu Tabelle 1-3 auf Seite 32 begeben. MySQL speichert jede Datenbank (auch als Schema bezeichnet) als Unterverzeichnis seines Datenverzeichnisses im zugrunde liegenden Dateisystem. Wenn Sie eine Tabelle erzeugen, speichert MySQL die Tabellendefinition in einer .frm-Datei mit dem gleichen Namen wie die Tabelle. Das heißt, wenn Sie eine Tabelle namens MyTable anlegen, speichert MySQL die Tabellendefinition in MyTable.frm. Da MySQL das Dateisystem ver-
Die Storage-Engines von MySQL |
15
wendet, um Datenbanknamen und Tabellendefinitionen abzulegen, hängt es von der Plattform ab, ob Groß- und Kleinschreibung eine Rolle spielen. Bei einer MySQL-Instanz unter Windows ist die Schreibweise von Tabellen- und Datenbanknamen egal, auf Unixartigen Systemen wird zwischen Groß- und Kleinschreibung unterschieden. Jede StorageEngine speichert die Daten und Indizes der Tabelle anders, der Server selbst arbeitet mit der Tabellendefinition. Um festzustellen, welche Storage-Engine eine bestimmte Tabelle verwendet, benutzen Sie den Befehl SHOW TABLE STATUS. Führen Sie z.B. folgenden Befehl aus, um die Tabelle user in der Datenbank mysql zu untersuchen: mysql> SHOW TABLE STATUS LIKE 'user' \G *************************** 1. row *************************** Name: user Engine: MyISAM Row_format: Dynamic Rows: 6 Avg_row_length: 59 Data_length: 356 Max_data_length: 4294967295 Index_length: 2048 Data_free: 0 Auto_increment: NULL Create_time: 2002-01-24 18:07:17 Update_time: 2002-01-24 21:56:29 Check_time: NULL Collation: utf8_bin Checksum: NULL Create_options: Comment: Users and global privileges 1 row in set (0.00 sec)
Die Ausgabe zeigt, dass es sich hier um eine MyISAM-Tabelle handelt. Sie werden in der Ausgabe vermutlich noch viele weitere Informationen und Statistiken bemerken. Schauen wir uns die Bedeutung der einzelnen Zeilen kurz an: Name
Der Name der Tabelle. Engine
Die Storage-Engine der Tabelle. In den alten MySQL-Versionen hieß diese Spalte Type, nicht Engine. Row_format
Das Format der Zeile bzw. des Datensatzes. Bei einer MyISAM-Tabelle kann es Dynamic, Fixed oder Compressed sein. Dynamische Zeilen variieren in der Länge, weil sie Felder variabler Länge enthalten, etwa VARCHAR oder BLOB. Feste Zeilen, die immer die gleiche Größe aufweisen, bestehen entsprechend aus Feldern, deren Länge nicht variiert, wie etwa CHAR und INTEGER. Komprimierte Zeilen existieren nur in komprimierten Tabellen (siehe »Komprimierte MyISAM-Tabellen« auf Seite 20).
16 |
Kapitel 1: Die MySQL-Architektur
Rows
Die Anzahl der Zeilen (Datensätze) in der Tabelle. Bei nichttransaktionsfähigen Tabellen ist diese Zahl immer genau, sonst handelt es sich eher um eine Schätzung. Avg_row_length
Gibt an, wie viele Bytes die durchschnittliche Zeile enthält. Data_length
Gibt an, wie viele Daten (in Bytes) die gesamte Tabelle enthält. Max_data_length
Die maximale Datenmenge, die diese Tabelle aufnehmen kann. Näheres erfahren Sie in »Speicherung« auf Seite 18. Index_length
Gibt an, wie viel Festplattenplatz die Indexdaten einnehmen. Data_free
Bei einer MyISAM-Tabelle ist das die Menge des zugewiesenen, aber momentan unbenutzten Platzes. Diese Menge enthält die zuvor gelöschten Zeilen und kann von künftigen INSERT-Anweisungen wieder zurückgefordert werden. Auto_increment
Der nächste AUTO_INCREMENT-Wert. Create_time
Gibt an, wann die Tabelle angelegt wurde. Update_time
Gibt an, wann die Daten in der Tabelle zuletzt geändert wurden. Check_time
Gibt an, wann die Tabelle zuletzt mit CHECK TABLE oder myisamchk überprüft wurde. Collation
Der Standardzeichensatz und die Sortierreihenfolge für Zeichenspalten in der Tabelle. Nähere Informationen über diese Eigenschaften finden Sie in »Zeichensätze und Sortierreihenfolgen« auf Seite 255. Checksum
Bei Aktivierung liefert diese Information eine aktuelle Checksumme des Inhalts der gesamten Tabelle. Create_options
Weitere Optionen, die beim Anlegen der Tabelle angegeben wurden. Comment
Dieses Feld enthält eine Reihe zusätzlicher Informationen. Bei einer MyISAMTabelle sind hier mögliche Kommentare enthalten, die beim Erzeugen der Tabelle angegeben wurden. Verwendet die Tabelle die InnoDB-Storage-Engine, dann steht hier die Menge des freien Platzes im InnoDB-Tablespace. Ist die Tabelle eine Sicht, dann enthält der Kommentar den Text »VIEW«.
Die Storage-Engines von MySQL |
17
Die MyISAM-Engine Als Standard-Storage-Engine von MySQL bietet MyISAM einen guten Kompromiss aus Leistung und nützlichen Funktionen, wie etwa Volltextindizierung, Komprimierung und raumbezogenen (GIS) Funktionen. MyISAM unterstützt weder Transaktionen noch zeilenorientierte (Row-Level) Locks.
Speicherung MyISAM speichert jede Tabelle typischerweise in zwei Dateien: einer Datendatei und einer Indexdatei. Die beiden Dateien tragen die Erweiterungen .MYD bzw. .MYI. Das MyISAM-Format ist plattformneutral, was bedeutet, dass Sie die Daten- und Indexdateien problemlos von einem Intel-basierten Server auf einen PowerPC oder eine Sun SPARC kopieren können. MyISAM-Tabellen können dynamische oder statische Zeilen (d.h. Zeilen fester Länge) enthalten. MySQL entscheidet anhand der Tabellendefinition, welches Format es verwendet. Die Anzahl der Zeilen, die eine MyISAM-Tabelle aufnehmen kann, wird hauptsächlich durch den verfügbaren Festplattenplatz auf Ihrem Datenbankserver und die größtmögliche Dateigröße bestimmt, die Ihr Betriebssystem erzeugen kann. MyISAM-Tabellen, die in MySQL 5.0 mit Zeilen variabler Länge erzeugt werden, können standardmäßig mit 256 TByte Daten umgehen und verwenden 6 Byte große Zeiger auf die Datensätze. Frühere MySQL-Versionen benutzten standardmäßig 4-Byte-Zeige für bis zu 4 GByte Daten. Alle MySQL-Versionen können mit Zeigergrößen bis zu 8 Byte umgehen. Um die Zeigergröße in einer MyISAM-Tabelle nach oben oder unten zu ändern, müssen Sie Werte für die Optionen MAX_ROWS und AVG_ROW_LENGTH angeben, die ungefähr den benötigten Platz repräsentieren: CREATE TABLE mytable ( a INTEGER NOT NULL PRIMARY KEY, b CHAR(18) NOT NULL ) MAX_ROWS = 1000000000 AVG_ROW_LENGTH = 32;
In diesem Beispiel haben wir MySQL mitgeteilt, dass es sich auf die Speicherung von wenigstens 32 GByte Daten in der Tabelle einstellen muss. Um festzustellen, was MySQL getan hat, fragen Sie einfach den Tabellenstatus ab: mysql> SHOW TABLE STATUS LIKE 'mytable' \G *************************** 1. row *************************** Name: mytable Engine: MyISAM Row_format: Fixed Rows: 0 Avg_row_length: 0 Data_length: 0 Max_data_length: 98784247807 Index_length: 1024 Data_free: 0 Auto_increment: NULL
18 |
Kapitel 1: Die MySQL-Architektur
Create_time: 2002-02-24 17:36:57 Update_time: 2002-02-24 17:36:57 Check_time: NULL Create_options: max_rows=1000000000 avg_row_length=32 Comment: 1 row in set (0.05 sec)
Wie Sie sehen können, hat sich MySQL genau die Optionen gemerkt, die Sie angegeben haben. Und es hat sich für eine Repräsentation entschieden, die 91 GByte Daten aufnehmen kann! Die Zeigergröße können Sie später mit der Anweisung ALTER TABLE ändern. Allerdings werden dabei die gesamte Tabelle und alle ihre Indizes neu geschrieben, was recht lange dauern kann.
MyISAM-Eigenschaften Als eine der ältesten Storage-Engines in MySQL besitzt MyISAM viele Eigenschaften, die im Laufe der Jahre entwickelt wurden, um bestimmte Lücken zu schließen: Locking und Nebenläufigkeit MyISAM sperrt ganze Tabellen, keine Zeilen. Lesende Operationen fordern Shared Locks (Lese-Locks) für alle Tabellen an, die sie lesen müssen. Schreibende Operationen fordern exklusive Locks (Schreib-Locks) an. Es ist allerdings möglich, neue Zeilen in die Tabelle einzufügen, während Auswahlabfragen darauf ausgeführt werden (nebenläufige oder parallele Einfügungen). Dies ist eine wichtige und sinnvolle Eigenart. Automatische Reparatur MySQL unterstützt die automatische Überprüfung und Reparatur von MyISAMTabellen. In »MyISAM-Ein-/Ausgabe verbessern« auf Seite 304 finden Sie weitere Informationen. Manuelle Reparatur Sie können die Befehle CHECK TABLE mytable und REPAIR TABLE mytable verwenden, um eine Tabelle auf Fehler zu überprüfen und diese zu beheben. Wenn der Server offline ist, haben Sie die Möglichkeit, die Überprüfung und Reparatur der Tabellen mit dem Kommandozeilenwerkzeug myisamchk vorzunehmen. Index-Funktionen In MyISAM-Tabellen können Sie Indizes der ersten 500 Zeichen von BLOB- und TEXTSpalten erzeugen. MyISAM unterstützt Volltextindizes, die einzelne Wörter für komplexe Suchoperationen indizieren. Weitere Informationen über die Indizierung finden Sie in Kapitel 3. Verzögertes Schreiben von Schlüsseln MyISAM-Tabellen, die mit der Option DELAY_KEY_WRITE erzeugt wurden, schreiben am Ende einer Abfrage keine geänderten Indexdaten auf die Festplatte. Stattdessen puffert MyISAM die Änderungen in einem Schlüsselpuffer im Speicher. Die Indexblöcke werden erst dann auf die Platte geschrieben, wenn der Puffer geleert oder die Tabelle geschlossen wird. Bei sich häufig ändernden Tabellen kann dies zu einer deutlichen
Die Storage-Engines von MySQL |
19
Leistungssteigerung führen. Nach einem Server- oder Systemabsturz werden die Indizes allerdings mit hoher Wahrscheinlichkeit beschädigt und müssen repariert werden. Sie sollten dies mit einem Skript erledigen, das myisamchk ausführt, bevor Sie den Server neu starten, oder indem Sie automatische Wiederherstellungsoptionen verwenden. (Selbst wenn Sie DELAY_KEY_WRITE nicht benutzen, sind diese Sicherheitsvorkehrungen eine ausgezeichnete Idee.) Sie können das verzögerte Schreiben der Schlüssel global oder für einzelne Tabellen konfigurieren.
Komprimierte MyISAM-Tabellen Manche Tabellen ändern sich nie, nachdem sie erzeugt und mit Daten gefüllt wurden – etwa in CD-ROM- oder DVD-ROM-basierten Anwendungen und Embedded-Umgebungen. Diese eignen sich dann besonders für komprimierte MyISAM-Tabellen. Sie können Tabellen mit dem Dienstprogramm myisampack komprimieren (oder »packen«). Komprimierte Tabellen lassen sich nicht mehr ändern (obwohl Sie sie bei Bedarf dekomprimieren, verändern und erneut komprimieren können), benötigen aber im Allgemeinen weniger Festplattenplatz. Dadurch sind sie schneller, da kleinere Dateien weniger Suchoperationen erfordern, um Datensätze zu finden. Komprimierte MyISAMTabellen können Indizes haben, sind aber schreibgeschützt. Bei moderner Hardware ist der benötigte Overhead für die Dekomprimierung der Daten für die meisten Anwendungen unerheblich, wo der wirkliche Nutzen in der Reduzierung der Festplattenzugriffe liegt. Die Zeilen werden einzeln komprimiert, so dass MySQL nicht die ganze Tabelle (oder eine Seite) entpacken muss, nur um eine einzige Zeile zu lesen.
Die MyISAM-Merge-Engine Die Merge-Engine ist eine Variante von MyISAM. Eine Merge-Tabelle bildet eine Kombination mehrerer identischer MyISAM-Tabellen in einer virtuellen Tabelle. Sie bietet sich vor allem an, wenn Sie MySQL in Logging- und Data-Warehouse-Anwendungen einsetzen. Eine ausführliche Besprechung der Merge-Tabellen finden Sie in »Merge-Tabellen und Partitionierung« auf Seite 273.
Die InnoDB-Engine InnoDB wurde für die Transaktionsverarbeitung geschaffen – speziell für die Verarbeitung vieler kurzlebiger Transaktionen, die normalerweise abgeschlossen und nicht zurückgenommen werden. Für die transaktionsfähige Speicherung ist dies die beliebteste Storage-Engine. Ihre Leistungsfähigkeit und die Fähigkeit zur automatischen Wiederherstellung nach Abstürzen hat jedoch auch zu ihrer Popularität für nichttransaktionsfähige Speicheranforderungen beigetragen.
20 |
Kapitel 1: Die MySQL-Architektur
InnoDB speichert seine Daten in einer oder mehreren Datendateien, die zusammen als Tablespace bezeichnet werden. Bei einem Tablespace handelt es sich im Prinzip um eine Blackbox, die InnoDB ganz allein verwaltet. In MySQL 4.1 und neueren Versionen kann InnoDB die Daten und Indizes jeder Tabelle in separaten Dateien ablegen. InnoDB kann auch direkt Festplattenpartitionen zum Aufbau seines Tablespace nutzen. Näheres hierzu finden Sie in »Der InnoDB-Tablespace« auf Seite 314. InnoDB verwendet MVCC, um eine hohe Nebenläufigkeit zu erreichen, und implementiert alle vier Standard-SQL-Isolationsebenen. Standardmäßig wird die Isolationsebene REPEATABLE READ benutzt. InnoDB setzt eine Next-Key-Locking-Strategie ein, um Phantom-Reads in dieser Isolationsebene zu vermeiden: Anstatt nur die Zeilen zu sperren, die Sie in einer Abfrage berührt haben, sperrt InnoDB auch Lücken in der Indexstruktur, wodurch verhindert wird, dass Phantome eingefügt werden. InnoDB-Tabellen bauen auf einem cluster-orientierten Index auf, den wir in Kapitel 3 behandeln. Die Indexstrukturen von InnoDB unterscheiden sich stark von denen der meisten anderen MySQL-Storage-Engines. Dadurch sind sehr schnelle Anfragen nach Primärschlüsseln möglich. Allerdings enthalten Sekundärindizes (Indizes, die nicht der Primärschlüssel sind) die Spalten mit den Primärschlüsseln; falls Ihr Primärschlüssel also groß ist, werden auch die anderen Indizes groß sein. Sie sollten sich um einen kleinen Primärschlüssel bemühen, falls Sie viele Indizes in einer Tabelle haben. InnoDB komprimiert nämlich seine Indizes nicht. Momentan ist InnoDB im Gegensatz zu MyISAM nicht dazu in der Lage, Indizes durch Sortierung aufzubauen. Daher lädt InnoDB die Daten und erzeugt die Indizes viel langsamer als MyISAM. Jede Operation, die die Struktur einer InnoDB-Tabelle ändert, baut die gesamte Tabelle einschließlich aller Indizes neu auf. InnoDB wurde entworfen, als die meisten Server langsame Festplatten, nur eine einzige CPU und begrenzte Speicherkapazität besaßen. Heutzutage, da Multicore-Server mit riesigen Speichern und schnellen Festplatten immer preiswerter werden, kommt es bei InnoDB zu Problemen mit der Skalierbarkeit. Die Entwickler von InnoDB kümmern sich um diese Probleme, zurzeit sind aber noch nicht alle gelöst. Im Abschnitt »InnoDB bei Nebenläufigkeit anpassen« auf Seite 321 erfahren Sie genauer, wie Sie eine hohe Nebenläufigkeit mit InnoDB erreichen. Neben der ausgezeichneten Nebenläufigkeit ist die Fremdschlüssel-Beschränkung eine ausgesprochen beliebte Eigenschaft von InnoDB, die nicht einmal der MySQL-Server bietet. InnoDB bietet darüber hinaus außerordentlich schnelle Lookups bei Abfragen, die einen Primärschlüssel verwenden. InnoDB besitzt eine Vielzahl interner Optimierungen. Dazu gehört vorausschauendes Read-Ahead (Vorwärts-Lesen) zum Vorabladen von Daten von der Festplatte, ein adaptiver Hash, der für sehr schnelle Suchen automatisch Indizes im Speicher aufbaut, und ein Eingabepuffer, um das Einfügen zu beschleunigen. Wir werden später ausführlich auf diese Optimierungen eingehen.
Die Storage-Engines von MySQL |
21
Das Verhalten von InnoDB ist sehr kompliziert. Wir empfehlen Ihnen, den Abschnitt »InnoDB Transaction Model and Locking« des MySQL-Handbuchs zu lesen, falls Sie InnoDB einsetzen. Es gibt eine Menge Überraschungen und Ausnahmen, derer Sie sich bewusst sein sollten, bevor Sie eine Anwendung mit InnoDB erstellen.
Die Memory-Engine Memory-Tabellen (früher als HEAP-Tabellen bezeichnet) sind sinnvoll, wenn Sie einen schnellen Zugriff auf Daten benötigen, die sich entweder nie ändern oder die nach einem Neustart nicht fortbestehen müssen. Memory-Tabellen sind im Allgemeinen um etwa eine Größenordnung schneller als MyISAM-Tabellen. Alle ihre Daten werden im Speicher abgelegt, Abfragen müssen deshalb nicht auf die Festplatten-Ein-/Ausgabe warten. Die Tabellenstruktur einer Memory-Tabelle überlebt einen Serverneustart, die Daten tun dies allerdings nicht. Hier sind einige gute Anwendungsfälle für Memory-Tabellen: • für »Lookup«- oder »Mapping«-Tabellen, wie etwa Tabellen, die Postleitzahlen zu Orten zuordnen • zum Speichern der Ergebnisse periodisch gesammelter Daten in einem Cache • für Zwischenergebnisse beim Analysieren von Daten Memory-Tabellen unterstützen HASH-Indizes, die bei Lookup-Abfragen sehr schnell arbeiten. In »Hash-Indizes« auf Seite 108 finden Sie weitere Informationen über HASH-Indizes. Obwohl Memory-Tabellen sehr schnell sind, eignen sie sich oft nicht als allgemeiner Ersatz für festplattenbasierte Tabellen. Sie verwenden ein tabellenorientiertes Locking, das für Schreibvorgänge nur eine niedrige Nebenläufigkeit gewährt, und sie unterstützen keine TEXT- oder BLOB-Spaltentypen. Außerdem unterstützen sie nur Zeilen fester Größe, so dass sie VARCHARs als CHARs ablegen, was eine Verschwendung von Speicher darstellt. MySQL benutzt die Memory-Engine intern, wenn es Abfragen verarbeitet, die eine temporäre Tabelle für Zwischenergebnisse benötigen. Wenn das Zwischenergebnis zu groß für eine Memory-Tabelle wird oder TEXT- oder BLOB-Spalten besitzt, konvertiert MySQL es in eine MyISAM-Tabelle auf der Festplatte um. Mehr dazu erfahren Sie in späteren Kapiteln. Oft werden Memory-Tabellen mit temporären Tabellen verwechselt, bei denen es sich um flüchtige Tabellen handelt, die mit CREATE TEMPORARY TABLE erzeugt wurden. Temporäre Tabellen können jede Storage-Engine verwenden, sie sind nicht identisch mit Tabellen, die die Memory-StorageEngine benutzen. Temporäre Tabellen sind nur für eine einzige Verbindung sichtbar und verschwinden komplett, wenn die Verbindung geschlossen wird.
22 |
Kapitel 1: Die MySQL-Architektur
Die Archive-Engine Die Archive-Engine unterstützt nur INSERT- und SELECT-Abfragen und bot vor MySQL 5.1 auch keine Unterstützung für Indizes. Sie verursacht weniger Festplattenzugriffe als MyISAM, da sie Schreibzugriffe auf Daten puffert und jede Zeile beim Einfügen mit zlib komprimiert. Jede SELECT-Abfrage erfordert außerdem einen kompletten Scan der Tabelle. Archive-Tabellen eignen sich daher ideal für das Logging und die Datenerfassung, wo bei der Analyse oft eine ganze Tabelle durchsucht wird oder wo man schnelle INSERT-Abfragen auf einem Replikations-Master haben will. Replikations-Slaves können für die gleiche Tabelle eine andere Storage-Engine verwenden. Das bedeutet, dass die Tabelle auf dem Slave Indizes für eine schnellere Performance bei der Analyse haben kann. (In Kapitel 8 finden Sie weitere Informationen über die Replikation.) Archive unterstützt ein Row-Level-Locking und ein besonderes Puffersystem für stark nebenläufiges Einfügen. Es bietet konsistente Leseoperationen, indem es ein SELECT stoppt, nachdem es die Anzahl der Zeilen bezogen hat, die in der Tabelle existierten, als die Abfrage begann. Außerdem lässt es massenhafte Einfügungen so lange unsichtbar, bis sie abgeschlossen sind. Diese Funktionen emulieren einige Aspekte der transaktionsfähigen und MVCC-Verhaltensweisen, allerdings ist Archive keine transaktionsfähige Storage-Engine. Es ist einfach eine Storage-Engine, die für schnelles Einfügen und komprimierte Speicherung optimiert wurde.
Die CSV-Engine Die CSV-Engine kann Dateien mit kommaseparierten Werten (CSV-Dateien) als Tabellen behandeln, unterstützt aber keine Indizes dafür. Diese Engine ermöglicht es Ihnen, Dateien in eine Datenbank hinein- und aus ihr herauszukopieren, während der Server läuft. Eine CSV-Datei, die Sie aus einer Tabellenkalkulation exportieren und im Datenverzeichnis des MySQL-Servers speichern, kann der Server sofort lesen. In gleicher Weise kann ein externes Programm Daten, die Sie in eine CSV-Tabelle schreiben, sofort lesen. CSV-Tabellen eignen sich besonders als Datenaustauschformat und für bestimmte Arten des Logging.
Die Federated-Engine Die Federated-Engine speichert Daten nicht lokal. Jede Federated-Tabelle verweist auf eine Tabelle auf einem entfernten MySQL-Server. Sie stellt also für alle Operationen eine Verbindung zu einem entfernten Server her. Sie wird gelegentlich verwendet, um »Hacks« zu ermöglichen, wie etwa Tricks bei der Replikation. In der aktuellen Implementierung dieser Engine gibt es viele Merkwürdigkeiten und Beschränkungen. Wir denken, dass die Federated-Engine sich aufgrund ihrer Funktionsweise am besten für Lookups nach einzelnen Zeilen anhand des Primärschlüssels oder für INSERT-Abfragen auf einem entfernten Server eignet. Bei Aggregatabfragen (zusammengesetzten Abfragen), Verknüpfungen (Joins) oder anderen grundlegenden Operationen funktioniert sie nicht besonders gut.
Die Storage-Engines von MySQL |
23
Die Blackhole-Engine Die Blackhole-Engine besitzt überhaupt keinen Speichermechanismus. Sie verwirft alle INSERTs, anstatt sie zu speichern. Allerdings schreibt der Server Abfragen an BlackholeTabellen wie gewöhnlich in seine Protokolle, so dass sie auf Slaves repliziert oder einfach im Log aufbewahrt werden können. Dadurch eignet sich die Blackhole-Engine ganz gut für ausgefallene Replikationskonfigurationen und für das Logging von Überprüfungen.
Die NDB-Cluster-Engine MySQL AB erwarb die NDB-Cluster-Engine im Jahre 2003 von Sony Ericsson. Ursprünglich war sie für Echtzeitanforderungen gedacht und bot Redundanz und Lastausgleich. Die Engine schrieb zwar ein Log auf die Festplatte, behielt aber alle Daten im Speicher und war für Primärschlüssel-Lookups optimiert. MySQL hat seitdem weitere Indizierungsmethoden und viele Optimierungen hinzugefügt, und MySQL 5.1 erlaubt die Speicherung einiger Spalten auf der Festplatte. Die NDB-Architektur ist einzigartig: Ein NDB-Cluster ist völlig anders als beispielsweise ein Oracle-Cluster. Die NDB-Infrastruktur basiert auf einem Shared-Nothing-Konzept. Es gibt kein Speichernetzwerk oder eine andere große, zentralisierte Speicherlösung, auf die andere Cluster-Typen zurückgreifen. Eine NDB-Datenbank besteht aus Datenknoten, Verwaltungsknoten und SQL-Knoten (MySQL-Instanzen). Jeder Datenknoten enthält ein Segment (»Fragment«) der Daten des Clusters. Die Fragmente werden dupliziert, so dass das System mehrere Kopien der gleichen Daten auf unterschiedlichen Knoten besitzt. Aus Gründen der Redundanz und der Hochverfügbarkeit ist üblicherweise jedem Knoten ein physischer Server zugeordnet. In diesem Sinn ist NDB mit einem RAID auf Serverebene vergleichbar. Die Verwaltungsknoten werden verwendet, um die zentralisierte Konfiguration zu beziehen sowie um die Cluster-Knoten zu überwachen und zu steuern. Alle Datenknoten kommunizieren miteinander, und alle MySQL-Server sind mit allen Datenknoten verbunden. Eine niedrige Netzwerklatenz ist außerordentlich wichtig für NDB-Cluster. Eine Warnung: NDB-Cluster ist eine ziemlich »coole« Technik und sicherlich einiger Untersuchungen wert, um Ihre Neugierde zu befriedigen, allerdings neigen viele Techniker dazu, Ausreden zu suchen, um sie einsetzen zu können, und versuchen, sie an Anforderungen anzupassen, für die sie definitiv nicht geeignet sind. Unserer Erfahrung nach erkennen viele Leute trotz sorgfältiger Überlegungen nicht, wo diese Engine wirklich sinnvoll ist und wie sie funktioniert, wenn sie sie nicht tatsächlich installiert und eine Weile benutzt haben. Dadurch wird meist eine Menge Zeit verschwendet, weil sie wirklich nicht als allgemein einsetzbare Storage-Engine gedacht ist. Schockierend wirkt oft, dass NDB Joins momentan auf der MySQL-Serverebene ausführt und nicht in der Storage-Engine. Da alle Daten für NDB über das Netzwerk bezogen werden müssen, sind komplexe Joins unwahrscheinlich langsam. Andererseits können Suchen in nur einer Tabelle sehr schnell ablaufen, da mehrere Datenknoten jeweils einen
24 |
Kapitel 1: Die MySQL-Architektur
Teil des Ergebnisses liefern. Dies ist nur einer der vielen Aspekte, die Sie berücksichtigen und verstehen müssen, wenn Sie NDB-Cluster für eine bestimmte Anwendung in Betracht ziehen. Die NDB-Cluster-Engine ist so groß und komplex, dass wir sie in diesem Buch nicht weiter behandeln werden. Falls Sie daran interessiert sind, sollten Sie sich ein Buch suchen, das sich speziell diesem Thema widmet. Stellen Sie sich jedoch darauf ein, dass die NDBCluster-Engine voraussichtlich nicht Ihren Erwartungen entsprechen wird und für die meisten traditionellen Anwendungen nicht die richtige Lösung ist.
Die Falcon-Engine Jim Starkey, ein Datenbankpionier, zu dessen früheren Erfindungen Interbase, MVCC und der Spaltentyp BLOB gehören, hat die Falcon-Engine entworfen. MySQL AB erwarb die Falcon-Technik im Jahre 2006, und Jim arbeitet momentan für MySQL AB. Falcon wurde mit Blick auf moderne Hardware entworfen – speziell für Server mit mehreren 64-Bit-Prozessoren und Unmengen an Speicher –, kann aber auch in bescheideneren Umgebungen agieren. Falcon verwendet MVCC und versucht, laufende Transaktionen vollständig im Speicher zu behalten. Daher sind Rollback- und Wiederherstellungsoperationen außerordentlich schnell. Falcon ist momentan noch nicht fertiggestellt (z.B. synchronisiert es seine Commits noch nicht mit dem Binärlog), so dass wir darüber kaum etwas mit Bestimmtheit sagen können. Selbst die ersten Benchmarks, die wir damit durchgeführt haben, werden wahrscheinlich schon wieder veraltet sein, wenn es für den allgemeinen Gebrauch freigegeben wird. Die Falcon-Engine scheint ein gutes Potenzial für viele Online-Anwendungen zu bieten, aber Genaueres wird sich erst mit der Zeit zeigen.
Die solidDB-Engine Die solidDB-Engine, entwickelt von Solid Information Technology (http://www.soliddb. com), ist eine transaktionsfähige Engine, die MVCC benutzt. Sie unterstützt als momentan einzige Engine sowohl pessimistische als auch optimistische Nebenläufigkeitskontrolle. Die solidDB für MySQL enthält eine vollständige Unterstützung für Fremdschlüssel. Sie ähnelt in vielerlei Hinsicht InnoDB, etwa in ihrer Verwendung von Cluster-Indizes. Die solidDB für MySQL enthält eine kostenlose Online-Backup-Möglichkeit. Die solidDB für MySQL ist ein vollständiges Paket, das aus der solidDB-Storage-Engine, der MyISAM-Storage-Engine und dem MySQL-Server besteht. Der »Kitt« zwischen der solidDB-Storage-Engine und dem MySQL-Server wurde Ende 2006 eingeführt. Die zugrunde liegende Technik und der Code haben sich jedoch im Laufe der 15-jährigen Geschichte des Unternehmens entwickelt. Solid zertifiziert und unterstützt das gesamte Produkt. Es unterliegt der GPL und wird kommerziell unter einem dualen Lizenzierungsmodell angeboten, das identisch mit dem des MySQL-Servers ist.
Die Storage-Engines von MySQL |
25
Die PBXT-(Primebase XT-)Engine Die PBXT-Engine, entwickelt von Paul McCullagh von der SNAP Innovation GmbH in Hamburg (http://www.primebase.com), ist eine transaktionsfähige Storage-Engine mit einem einmaligen Design. Eines ihrer charakteristischen Merkmale ist die Art, wie sie Transaktions-Logs und Datendateien einsetzt, um ein Write-Ahead-Logging zu vermeiden, wodurch sich der Overhead der Transaktions-Commits entscheidend verringert. Aufgrund dieser Architektur hat PBXT das Potenzial zu einer sehr hohen Nebenläufigkeit bei Schreiboperationen. Tests haben bereits bewiesen, dass diese Engine bei bestimmten Operationen schneller sein kann als InnoDB. PBXT verwendet MVCC und unterstützt Fremdschlüssel-Beschränkungen, setzt aber keine Cluster-Indizes ein. PBXT ist eine relativ neue Engine und muss sich erst noch in Produktionsumgebungen bewähren. So wurde etwa die Implementierung für wirklich dauerhafte Transaktionen erst während der Entstehung dieses Buches abgeschlossen. Als Ergänzung zu PBXT arbeitet man bei SNAP Innovation an einer skalierbaren »BlobStreaming«-Infrastruktur (http://www.blobstreaming.org). Diese soll in der Lage sein, große Mengen an Binärdaten effizient zu speichern und abzurufen.
Die Maria-Storage-Engine Maria ist eine neue Storage-Engine, die von einigen der besten MySQL-Entwickler entwickelt wird, etwa von Michael Widenius, der MySQL geschaffen hat. Die Version 1.0 enthält nur einige der geplanten Funktionen. Das Ziel besteht darin, Maria als Ersatz für MyISAM zu verwenden, das momentan die Standard-Storage-Engine von MySQL ist und das der Server intern für solche Aufgaben wie Privilege Tables und temporäre Tabellen benutzt, die beim Ausführen von Abfragen erzeugt werden. Hier sind einige Besonderheiten aus dem Plan: • das tabellenweise Festlegen einer transaktionsfähigen oder nichttransaktionsfähigen Speicherung • die Wiederherstellung nach Abstürzen, selbst wenn die Tabelle im nichttransaktionsfähigen Modus läuft • Row-Level-Locking und MVCC • bessere BLOB-Verarbeitung
Weitere Storage-Engines Mehrere Dritthersteller bieten weitere (manchmal proprietäre) Engines an. Außerdem gibt es eine Unmenge spezialisierter und experimenteller Engines (z.B. eine Engine zum Abfragen von Webservices). Einige dieser Engines werden eher so nebenbei entwickelt, manchmal nur von einem oder zwei Entwicklern. Es ist nämlich recht einfach, eine Storage-Engine für MySQL herzustellen. Die meisten dieser Engines sind allerdings nicht weit verbreitet, weil sie oft nur begrenzt einsetzbar sind. Wir überlassen es Ihnen, diese Angebote zu erkunden.
26 |
Kapitel 1: Die MySQL-Architektur
Die richtige Engine auswählen Wenn Sie MySQL-basierte Anwendungen entwerfen, müssen Sie entscheiden, welche Storage-Engine Sie zum Speichern Ihrer Daten verwenden. Falls Sie nicht schon in der Entwurfsphase darüber nachdenken, werden Sie wahrscheinlich später mit Schwierigkeiten rechnen müssen. Möglicherweise merken Sie dann, dass die vorgegebene Engine eine gewünschte Funktion, wie etwa Transaktionen, nicht bietet oder dass der Mix aus Leseund Schreibabfragen, den Ihre Anwendung generiert, eine größere Granularität beim Locking erfordert, als die Tabellen-Locks von MyISAM erlauben. Da Sie die Storage-Engines tabellenweise angeben können, müssen Sie eine klare Vorstellung davon haben, wie die einzelnen Tabellen verwendet werden und welche Daten sie speichern sollen. Es ist außerdem hilfreich, wenn man ein gutes Verständnis für die Anwendung als Ganzes und ihr Wachstumspotenzial hat. Ausgestattet mit diesen Informationen können Sie darangehen, sinnvolle Entscheidungen darüber zu treffen, welche Storage-Engines letztendlich zum Zuge kommen. Es ist nicht unbedingt eine gute Idee, für unterschiedliche Tabellen auch unterschiedliche Storage-Engines zu verwenden. Wenn es sich einrichten lässt, sollten Sie sich für eine Storage-Engine entscheiden. Sie werden sich Ihr Leben damit deutlich erleichtern.
Überlegungen Es gibt zwar viele Faktoren, die Ihre Entscheidung beeinflussen können, welche StorageEngines zum Einsatz kommen, normalerweise läuft es aber auf ein paar wesentliche Überlegungen hinaus. Hier sind die wichtigsten Dinge, die Sie beachten sollten: Transaktionen Falls Ihre Anwendung Transaktionen erfordert, dann ist InnoDB momentan die stabilste, am besten integrierte und bewährte Wahl. Wir gehen aber davon aus, dass andere transaktionsfähige Engines mit der Zeit eine starke Konkurrenz bilden werden. MyISAM ist eine gute Wahl, wenn eine Aufgabe keine Transaktionen erfordert und vor allem SELECT- oder INSERT-Abfragen ausführt. Manchmal fallen bestimmte Komponenten einer Anwendung (wie etwa das Logging) in diese Kategorie. Nebenläufigkeit (Concurrency) Wie Sie am besten Ihre Anforderungen an die Nebenläufigkeit befriedigen, hängt von Ihrer Arbeitslast ab. Falls Sie nur parallel einfügen und lesen müssen, dann ist, ob Sie es glauben oder nicht, MyISAM eine gute Wahl! Müssen Sie dagegen dafür sorgen, dass ein Mix aus Operationen nebenläufig ausgeführt wird, ohne dass sie sich in die Quere kommen, dann sollten Sie sich für eine der Engines mit RowLevel-Locking entscheiden.
Die Storage-Engines von MySQL |
27
Backups Die Forderung nach regelmäßig durchgeführten Backups könnte ebenfalls die Wahl Ihrer Tabelle beeinflussen. Falls es kein Problem ist, den Server zum Erstellen von Backups regelmäßig herunterzufahren, dann ist es auch einfach, eine Storage-Engine zu wählen. Falls Sie dagegen in irgendeiner Form Online-Backups durchführen müssen, wird es weniger einfach. In Kapitel 11 wird dieses Thema näher betrachtet. Denken Sie auch daran, dass sich bei Verwendung mehrerer Storage-Engines die Komplexität der Backups und der Servereinrichtung erhöht. Wiederherstellung nach Abstürzen Wenn Sie viele Daten haben, müssen Sie ernsthaft darüber nachdenken, wie lange es dauert, das System nach einem Absturz wiederherzustellen. MyISAM-Tabellen werden z.B. im Allgemeinen leichter zerstört und brauchen viel länger für die Wiederherstellung als InnoDB-Tabellen. Um genau zu sein, ist das sogar einer der wichtigsten Gründe dafür, weshalb so viele Leute InnoDB verwenden, obwohl sie keine Transaktionen benötigen. Besondere Eigenschaften Manchmal werden Sie feststellen, dass eine Anwendung auf bestimmte Funktionen oder Optimierungen zurückgreift, die nur einige der MySQL-Storage-Engines zu bieten haben. Zum Beispiel sind viele Anwendungen auf Cluster-Index-Optimierungen angewiesen. Momentan beschränkt Sie dies auf InnoDB und solidDB. Andererseits unterstützt nur MyISAM eine Volltextsuche in MySQL. Wenn eine StorageEngine eine oder mehrere wichtige Anforderungen erfüllt, andere dagegen nicht, dann müssen Sie entweder einen Kompromiss eingehen oder eine clevere Designlösung finden. Oft bekommen Sie das, was Sie brauchen, von einer Storage-Engine, die Ihre Anforderungen scheinbar nicht unterstützt. Sie müssen sich nicht sofort entscheiden. Im Rest dieses Buches erfahren Sie noch eine Menge über die Stärken und Schwächen der einzelnen Storage-Engines und erhalten viele Tipps zu Architektur und Entwurf. Meist gibt es mehr Möglichkeiten, als Sie wahrscheinlich jetzt erkennen, und vermutlich hilft es, später auf die Frage der richtigen StorageEngine zurückzukommen.
Praktische Beispiele Ohne Beispiele aus dem richtigen Leben wirken diese Probleme und Überlegungen vermutlich ziemlich abstrakt. Betrachten wir deshalb einige verbreitete Datenbankanwendungen. Wir schauen uns verschiedene Tabellen an und stellen fest, welche Engine deren Anforderungen am besten entgegenkommt. Eine Zusammenfassung der Möglichkeiten finden Sie im nächsten Abschnitt.
Logging Nehmen wir an, Sie wollen mit MySQL in Echtzeit jeden Anruf über eine zentrale Telefonanlage festhalten. Oder vielleicht haben Sie mod_log_sql für Apache installiert, so 28 |
Kapitel 1: Die MySQL-Architektur
dass Sie alle Besuche Ihrer Website direkt in einer Tabelle festhalten können. Bei einer solchen Anwendung ist Geschwindigkeit wohl das wesentliche Ziel, und die Datenbank soll dabei nicht einen Flaschenhals bilden. Die Storage-Engines MyISAM und Archive würden hier ganz gut funktionieren, da sie einen relativ geringen Overhead verursachen und Tausende von Datensätzen pro Sekunde aufzeichnen können. Auch die PBXTStorage-Engine ist vermutlich besonders für Logging-Aufgaben geeignet. Interessant wird es, wenn Sie beschließen, Berichte anzufertigen, die die aufgezeichneten Daten zusammenfassen. Je nach den verwendeten Abfragen wird sich das Einfügen der Datensätze deutlich verlangsamen, während Sie die Daten für den Bericht sammeln. Was können Sie tun? Eine Lösung besteht darin, die Daten mithilfe der in MySQL fest eingebaute Replikation auf einen zweiten (Slave-)Server zu klonen. Die zeit- und CPU-intensiven Abfragen können dann auf dem Slave ausgeführt werden. Der Master kann die Datensätze weiterhin so schnell einfügen wie bisher, während Sie auf dem Slave beliebige Abfragen durchführen können, ohne sich Gedanken darüber machen zu müssen, ob diese das Echtzeit-Logging negativ beeinflussen. Sie können Abfragen auch in Zeiten mit niedriger Last durchführen, allerdings dürfen Sie sich nicht darauf verlassen, dass diese Strategie noch funktioniert, wenn Ihre Anwendung wächst. Eine weitere Möglichkeit ist die Verwendung einer Merge-Tabelle. Anstatt die Daten immer in die gleiche Tabelle zu schreiben, passen Sie die Anwendung so an, dass sie in eine Tabelle schreibt, die das Jahr oder den Namen bzw. die Nummer des Monats in ihrem Namen enthält: web_logs_2008_01 oder web_logs_2008_jan. Definieren Sie dann eine Merge-Tabelle, die die Daten enthält, die Sie zusammenfassen wollen, und verwenden Sie diese in Ihren Abfragen. Auch falls Sie die Daten täglich oder wöchentlich zusammenfassen müssen, funktioniert diese Strategie, Sie müssen einfach nur Tabellen mit spezielleren Namen anlegen, wie etwa web_logs_2008_01_01. Während Sie Abfragen in Tabellen durchführen, in die nicht mehr geschrieben wird, kann Ihre Anwendung ungestört Datensätze in der aktuellen Tabelle aufzeichnen.
Nur (oder hauptsächlich) gelesene Tabellen Aus Tabellen, deren Daten zum Aufbau eines Katalogs oder einer Liste (Jobs, Auktionen, Immobilien usw.) verwendet werden, wird normalerweise viel häufiger gelesen, als dass in sie geschrieben wird. Das macht sie zu guten Kandidaten für MyISAM – falls es Ihnen egal ist, was passiert, wenn MyISAM abstürzt. Unterschätzen Sie nicht, wie wichtig das ist; viele Anwender verstehen nicht, wie riskant es ist, eine Storage-Engine zu benutzen, die sich nicht einmal ernsthaft darum bemüht, ihre Daten auf die Platte zu schreiben.
Die Storage-Engines von MySQL |
29
Es ist eine ausgezeichnete Idee, eine realistische Lastsimulation auf einem Testserver durchzuführen und dann im wahrsten Sinne des Wortes den Stecker zu ziehen. Die Erfahrungen, die Sie bei der Wiederherstellung nach einem Absturz machen werden, sind unbezahlbar. Sie ersparen Ihnen hässliche Überraschungen im tatsächlichen Betrieb.
Vertrauen Sie nicht einfach auf die verbreitete Volksweisheit »MyISAM ist schneller als InnoDB«. Sie ist nicht grundsätzlich wahr. Wir können Ihnen Dutzende von Situationen nennen, in denen InnoDB MyISAM weit hinter sich lässt, vor allem bei Anwendungen, in denen Cluster-Indizes sinnvoll sind oder bei denen die Daten in den Speicher passen. Wenn Sie den Rest dieses Buches lesen, bekommen Sie ein Gespür dafür, welche Faktoren die Leistung einer Storage-Engine beeinflussen (Datengröße, Anzahl der notwendigen Ein-/Ausgabeoperationen, Primärschlüssel gegen Sekundärindizes usw.) und welche davon für Ihre Anwendung wichtig sind.
Auftragsverarbeitung Wenn Sie es mit irgendeiner Art von Auftragsverarbeitung zu tun haben, dann sind Transaktionen ein Muss. Halb abgearbeitete Bestellungen würden Ihren Dienst beim Kunden nicht unbedingt beliebt machen. Eine weitere wichtige Überlegung ist, ob die Engine Fremdschlüssel-Beschränkungen unterstützen muss. Zurzeit ist wahrscheinlich InnoDB am besten für Anwendungen zur Auftragsbearbeitung geeignet, obwohl auch die anderen transaktionsfähigen Storage-Engines heiße Kandidaten sind.
Aktienkurse Falls Sie Aktienkurse für die eigene Analyse sammeln, ist MyISAM – mit den üblichen Warnungen – eine gute Wahl. Betreiben Sie jedoch einen stark frequentierten Webservice, der Aktienkurse in Echtzeit sammelt und Tausende von Benutzern bedient, dann sollte eine Abfrage nie warten müssen. Zu jedem Zeitpunkt könnten viele Clients versuchen, die Tabelle zu lesen bzw. zu schreiben. Deshalb stellt Row-Level-Locking oder ein Entwurf, der Updates minimiert, die beste Lösung dar.
Schwarze Bretter und Thread-fähige Diskussionsforen Thread-fähige Diskussionsforen sind für MySQL-Benutzer ein interessantes Problem. Es gibt dafür Hunderte von frei verfügbaren PHP- und Perl-basierten Systemen. Bei vielen von ihnen wurde die Effizienz der Datenbank nicht berücksichtigt, so dass sie dazu neigen, für jede Anforderung eine große Anzahl von Abfragen auszuführen. Einige von ihnen wurden unabhängig von einer bestimmten Datenbank geschrieben, so dass sie die Vorteile von bestimmten Datenbanksystemen nicht ausnutzen. Gleichzeitig müssen die Zähler und Statistiken für die verschiedenen Diskussionen aktualisiert werden. Viele der Systeme benutzen darüber hinaus nur wenige monolithische Tabellen, um ihre Daten zu
30 |
Kapitel 1: Die MySQL-Architektur
speichern. Dementsprechend konzentrieren sich die starken Schreib-/Leseaktivitäten auf einige zentrale Tabellen, und die zur Wahrung der Konsistenz notwendigen Locks werden zu einer steten Quelle des Wettstreits. Ungeachtet ihrer Entwurfsmängel funktionieren die meisten Systeme bei kleiner und mittlerer Last ganz gut. Wenn eine Website jedoch wächst und eine Menge Verkehr generiert, kann sie sehr langsam werden. Die offensichtliche Lösung besteht darin, auf eine andere Storage-Engine zu wechseln, die in der Lage ist, mit dem gestiegenen Lese-/ Schreibaufkommen klarzukommen. Benutzer, die dies versuchen, werden manchmal allerdings überrascht sein, wenn sie feststellen, dass die Systeme sogar noch langsamer laufen als vorher! Diese Benutzer bemerken nicht, dass das System eine bestimmte Abfrage verwendet, die normalerweise ungefähr so aussieht: mysql> SELECT COUNT(*) FROM table;
Das Problem ist, dass nicht alle Engines diese Abfrage schnell ausführen können: MyISAM kann es, andere Engines möglicherweise nicht. Für jede Engine gibt es ähnliche Beispiele. In Kapitel 2 erfahren Sie, wie Sie sich vor solchen Überraschungen schützen und Lösungen für dieses Problem finden können.
CD-ROM-Anwendungen Wenn Sie eine CD-ROM- oder DVD-ROM-basierte Anwendung vertreiben müssen, die MySQL-Datendateien verwendet, dann sollten Sie in Betracht ziehen, MyISAM oder komprimierte MyISAM-Tabellen zu verwenden, die leicht isoliert und auf andere Medien kopiert werden können. Komprimierte MyISAM-Tabellen benötigen viel weniger Platz als unkomprimierte, sind allerdings schreibgeschützt. Bei bestimmten Anwendungen kann das problematisch werden, da die Daten aber sowieso auf ein schreibgeschütztes Medium kommen sollen, besteht wenig Grund dafür, unkomprimierte Tabellen für diese spezielle Aufgabe einzusetzen.
Storage-Engine-Zusammenfassung Tabelle 1-3 fasst die transaktions- und Locking-bezogenen Eigenschaften der beliebtesten MySQL-Storage-Engines zusammen. Die Spalte mit der MySQL-Version zeigt die minimale MySQL-Version, die Sie benötigen, um die Engine zu verwenden. Für einige Engines und MySQL-Versionen müssen Sie allerdings Ihren eigenen Server kompilieren. Das Wort »Alle« in dieser Spalte bedeutet alle Versionen seit MySQL 3.23.
Die Storage-Engines von MySQL |
31
Tabelle 1-3: Zusammenfassung der MySQL-Storage-Engines Storage-Engine
MySQL-Version
Transaktionen
MyISAM
Alle
Nein
LockingGranularität
Wichtige Anwendungen
Gegenanzeigen
Tabelle mit nebenläufigen Einfügungen
SELECT, INSERT, Laden
Gemischte Lese-/ Schreiblast
großer Mengen
MyISAM Merge
Alle
Nein
Tabelle mit nebenläufigen Einfügungen
Segmentierte Archivierung, Data- Warehouses
Viele globale Lookups
Memory (HEAP)
Alle
Nein
Tabelle
Zwischenberechnungen, statischer Lookup
Große Datensätze, persistente Speicherung
InnoDB
Alle
Ja
Zeilenorientiert (Row-Level) mit MVCC
Transaktionsfähige Verarbeitung
Keine
Falcon
6.0
Ja
Zeilenorientiert (Row-Level) mit MVCC
Transaktionsfähige Verarbeitung
Keine
Archive
4.1
Ja
Zeilenorientiert (Row-Level)
Logging, Gesamtanalyse
Zufälliger Zugriff, Updates, Löschungen
CSV
4.1
Nein
Tabelle
Logging, massenhaftes Laden externer Daten
Zufälliger Zugriff, Indizierung
Blackhole
4.1
Ja
Row-Level mit MVCC
geloggte oder replizierte Archivierung
Alle bis auf die vorgesehenen Anwendungen
Federated
5.0
N/A
N/A
Verteilte Datenquellen
Alle bis auf die vorgesehene Anwendung
NDB Cluster
5.0
Ja
Zeilenorientiert (Row-Level)
Hochverfügbarkeit
Die meisten typischen Anwendungen
PBXT
5.0
Ja
Zeilenorientiert (Row-Level) mit MVCC
Transaktionsfähige Verarbeitung, Logging
Bedarf an ClusterIndizes
solidDB
5.0
Ja
Zeilenorientiert (Row-Level) mit MVCC
Transaktionsfähige Verarbeitung
Keine
Maria (geplant)
6.x
Ja
Zeilenorientiert (Row-Level) mit MVCC
MyISAM-Ersatz
Keine
32 |
Kapitel 1: Die MySQL-Architektur
Tabellenkonvertierungen Es gibt verschiedene Möglichkeiten, eine Tabelle von einer Storage-Engine in eine andere zu konvertieren, die jeweils Vor- und Nachteile haben. In den folgenden Abschnitten beschreiben wir drei der gebräuchlichsten Methoden.
ALTER TABLE Die einfachste Möglichkeit, eine Tabelle von einer Engine zu einer anderen zu verschieben, besteht in der Anweisung ALTER TABLE. Der folgende Befehl konvertiert mytable zu Falcon: mysql> ALTER TABLE mytable ENGINE = Falcon;
Diese Syntax funktioniert bei allen Storage-Engines, es gibt allerdings einen Haken: Es kann sehr lange dauern. MySQL kopiert die alte Tabelle zeilenweise in die neue Tabelle. Während dieser Zeit wird wahrscheinlich die komplette Ein-/Ausgabekapazität der Festplatte des Servers beansprucht, und die Originaltabelle wird zum Lesen gesperrt, während die Konvertierung läuft. Denken Sie also zweimal nach, bevor Sie diese Technik auf einer ausgelasteten Tabelle einsetzen. Greifen Sie vielleicht lieber auf eine der anderen vorgestellten Methoden zurück, bei denen zuerst eine Kopie der Tabelle erstellt wird. Wenn Sie von einer Storage-Engine in eine andere konvertieren, gehen alle StorageEngine-spezifischen Eigenschaften verloren. Falls Sie etwa eine InnoDB-Tabelle nach MyISAM und wieder zurück konvertieren, verlieren Sie alle Fremdschlüssel, die Sie ursprünglich in der InnoDB-Tabelle definiert hatten.
Dump und Import Um den Konvertierungsvorgang besser kontrollieren zu können, könnten Sie die Tabelle zuerst mit dem Dienstprogramm mysqldump in eine Textdatei speichern. Anschließend bearbeiten Sie einfach die Dump-Datei, um die CREATE TABLE-Anweisung anzupassen, die sie enthält. Denken Sie daran, sowohl den Tabellennamen als auch ihren Typ zu ändern, da es nämlich nicht möglich ist, zwei Tabellen des gleichen Namens in der Datenbank vorzuhalten, selbst wenn sie einen unterschiedlichen Typ aufweisen – und mysqldump schreibt standardmäßig den Befehl DROP TABLE vor CREATE TABLE, so dass Ihre Daten verloren gehen, wenn Sie nicht aufpassen! In Kapitel 11 finden Sie weitere Hinweise über das effiziente Dumpen und Neuladen von Daten.
CREATE und SELECT Die dritte Konvertierungstechnik ist ein Kompromiss aus der Geschwindigkeit des ersten und der Sicherheit des zweiten Mechanismus. Anstatt die gesamte Tabelle als Dump zu speichern oder alles auf einmal zu konvertieren, legen Sie die neue Tabelle an und verwenden die MySQL-Syntax INSERT ... SELECT, um sie zu füllen:
Die Storage-Engines von MySQL |
33
mysql> CREATE TABLE innodb_table LIKE myisam_table; mysql> ALTER TABLE innodb_table ENGINE=InnoDB; mysql> INSERT INTO innodb_table SELECT * FROM myisam_table;
Das funktioniert gut, wenn Sie nicht viele Daten haben. Müssen dagegen viele Daten konvertiert werden, ist es oft effizienter, die Tabelle schrittweise zu füllen und die Transaktion zwischen jedem Schritt zu bestätigen, damit die »Undo-Logs« nicht zu groß werden. Nehmen Sie an, dass id der Primärschlüssel ist. Führen Sie dann diese Abfrage wiederholt aus (wobei Sie jedes Mal größere Werte für x und y benutzen), bis Sie alle Daten in die neue Tabelle kopiert haben: mysql> mysql> -> mysql>
START TRANSACTION; INSERT INTO innodb_table SELECT * FROM myisam_table WHERE id BETWEEN x AND y; COMMIT;
Anschließend haben Sie die Originaltabelle, die Sie schließen können, wenn Sie fertig sind, und die neue Tabelle, die nun vollständig gefüllt ist. Denken Sie daran, die Originaltabelle zu sperren, damit Sie keine inkonsistente Kopie der Daten erhalten!
34 |
Kapitel 1: Die MySQL-Architektur
KAPITEL 2
Engpässe finden: Benchmarking und Profiling
Irgendwann wird es so weit sein, dass Sie mehr Leistung von MySQL benötigen. Aber was sollten Sie versuchen zu verbessern? Eine bestimmte Abfrage? Ihr Schema? Ihre Hardware? Sie werden es nur herausfinden, wenn Sie messen, was Ihr System tut, und seine Leistung unter verschiedenen Bedingungen testen. Aus diesem Grund haben wir dieses Kapitel bereits so früh in das Buch eingefügt. Die beste Strategie besteht darin, die schwächste Verbindung in der Kette der Komponenten Ihrer Anwendung zu finden. Das ist vor allem dann sinnvoll, wenn Sie nicht wissen, was eine bessere Performance verhindert – oder was eine bessere Performance in der Zukunft verhindern wird. Benchmarking und Profiling sind zwei wichtige Techniken, um Flaschenhälse zu ermitteln. Sie sind miteinander verwandt, aber nicht identisch. Ein Benchmark misst die Leistung Ihres Systems. Das kann helfen, die Kapazität eines Systems festzustellen, zu zeigen, welche Änderungen eine Rolle spielen und welche nicht, oder zu zeigen, wie Ihre Anwendung mit unterschiedlichen Daten funktioniert. Im Gegensatz dazu hilft Ihnen Profiling dabei, herauszufinden, wo Ihre Anwendung die meiste Zeit verbringt oder die meisten Ressourcen beansprucht. Mit anderen Worten, Benchmarking beantwortet die Frage »Wie gut funktioniert das?«, und Profiling beantwortet die Frage »Wieso funktioniert es so?«. Wir haben dieses Kapitel in zwei Teile aufgeteilt: Der erste Teil handelt vom Benchmarking, im zweiten geht es um Profiling. Wir beginnen mit einer Diskussion der Gründe und Strategien für das Benchmarking und kommen dann zu speziellen Taktiken dafür. Wir zeigen Ihnen, wie man Benchmarks plant und entwirft, wie man für exakte Ergebnisse entwirft, Benchmarks durchführt und die Ergebnisse analysiert. Zum Ende des ersten Teils betrachten wir Benchmarking-Werkzeuge und schauen uns Beispiele für deren Einsatz an. Im zweiten Teil des Kapitels erfahren Sie, wie man sowohl Anwendungen als auch MySQL profiliert. Wir zeigen Beispiele für echten Profilierungscode, den wir in der Produktion verwendet haben, um uns bei der Analyse der Performance von Anwendungen
|
35
zu unterstützen. Darüber hinaus zeigen wir, wie man die Abfragen von MySQL protokolliert, die Logs analysiert und die Statuszähler von MySQL und andere Werkzeuge einsetzt, um festzustellen, was MySQL und Ihre Abfragen tun.
Wozu Benchmarks? Bei vielen mittleren bis großen MySQL-Anwendungsfällen gibt es Leute, die sich speziell um das Benchmarking kümmern. Allerdings sollte jeder Entwickler und Datenbankadministrator mit grundlegenden Benchmarking-Prinzipien und -Techniken vertraut sein. Benchmarks können sehr hilfreich für Sie sein: • Messen Sie, wie Ihre Anwendung momentan arbeitet. Wenn Sie nicht wissen, wie schnell sie im Moment läuft, können Sie nicht sicher sein, ob Änderungen, die Sie vornehmen, überhaupt einen Sinn haben. Mithilfe älterer Benchmark-Ergebnisse können Sie Probleme erkennen, die Sie nicht vorhergesehen haben. • Validieren Sie die Skalierbarkeit Ihres Systems. Mit einem Benchmark könnten Sie eine viel höhere Last simulieren, als Ihre Produktionssysteme verarbeiten, etwa den tausendfachen Anstieg der Benutzerzahl. • Berücksichtigen Sie das Wachstum bei Ihrer Planung. Benchmarks helfen Ihnen dabei, abzuschätzen, wie viel Hardware, Netzwerkkapazität und andere Ressourcen Sie für Ihre vorgesehene künftige Last benötigen. Damit verringern Sie das Risiko bei Upgrades oder größeren Änderungen der Anwendung. • Testen Sie die Fähigkeit Ihrer Anwendung, eine sich ändernde Umgebung zu tolerieren. Beispielsweise können Sie feststellen, wie Ihre Anwendung bei einer sporadisch auftretenden Spitze in der Nebenläufigkeit oder mit einer anderen Serverkonfiguration funktioniert oder wie Sie mit einer anderen Datenverteilung zurechtkommt. • Testen Sie unterschiedliche Hardware-, Software- und Betriebssystemkonfigurationen. Ist RAID 5 oder RAID 10 besser für Ihr System? Wie ändert sich die Leistung von zufälligen Schreiboperationen, wenn Sie von ATA-Festplatten auf SAN-Speicherung umstellen? Skaliert der 2.4-Linux-Kernel besser als der 2.6-Kernel? Nützt eine höhere MySQL-Version der Leistung? Was ist mit einer anderen Storage-Engine für Ihre Daten? Diese Fragen können Sie mit speziellen Benchmarks beantworten. Benchmarks können Sie auch für andere Zwecke einsetzen, etwa um eine einheitliche Testsuite für Ihre Anwendung zu schaffen; wir konzentrieren uns hier jedoch auf die leistungsbezogenen Aspekte.
Benchmarking-Strategien Es gibt zwei vorrangige Benchmarking-Strategien: Sie können die Anwendung als Ganzes bewerten oder MySQL allein betrachten. Diese beiden Strategien werden als Full-Stackbzw. Single-Component-Benchmarking bezeichnet. Es gibt verschiedene Gründe, eine Anwendung als Ganzes zu messen, anstatt sich nur auf MySQL zu beschränken:
36 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
• Sie testen die gesamte Anwendung, einschließlich des Webservers, des Anwendungscodes und der Datenbank. Das ist sinnvoll, weil Sie sich nicht um die Leistung von MySQL im Speziellen kümmern; Ihnen geht es um die ganze Anwendung. • MySQL bildet nicht immer die Engstelle der Anwendung. Ein Full-Stack-Benchmark kann dies beweisen. • Nur durch das Testen der ganzen Anwendung können Sie feststellen, wie sich der Cache der einzelnen Teile verhält. • Benchmarks sind nur so weit gut, dass sie das Verhalten der eigentlichen Anwendung widerspiegeln, was schwer festzustellen ist, wenn Sie nur einen Teil davon testen. Andererseits sind Anwendungs-Benchmarks unter Umständen schwer herzustellen und noch schwerer korrekt einzurichten. Wenn Sie einen Benchmark schlecht gestalten, treffen Sie möglicherweise falsche Entscheidungen, weil die Ergebnisse gar nicht die Wirklichkeit wiedergeben. Manchmal jedoch wollen Sie nicht über die ganze Anwendung informiert werden. Sie brauchen vielleicht nur einen MySQL-Benchmark, zumindest anfangs. Solch ein Benchmark ist sinnvoll, wenn: • Sie verschiedene Schemata oder Abfragen vergleichen wollen • Sie ein spezielles Problem testen wollen, das Sie in der Anwendung festgestellt haben • Sie einen langen Benchmark zu Gunsten eines kürzeren vermeiden wollen, der einen schnelleren Zyklus von Änderung und Messung erlaubt Es ist darüber hinaus sinnvoll, Benchmark-Tests mit MySQL durchzuführen, wenn Sie die Abfragen Ihrer Anwendung an einer echten Datenmenge wiederholen können. Die Daten selbst und die Größe der Datenmenge müssen realistisch sein. Nutzen Sie nach Möglichkeit einen Schnappschuss von tatsächlichen Produktionsdaten. Leider kann das Einrichten eines realistischen Benchmarks kompliziert und zeitaufwendig sein, und Sie haben Glück, wenn Sie eine Kopie von Produktionsdaten bekommen. Das kann natürlich auch unmöglich sein – stellen Sie sich etwa vor, Sie entwickeln eine neue Anwendung, die nur wenige Benutzer und kaum Daten hat. Wenn Sie wissen wollen, wie sie funktioniert, wenn sie sehr groß wird, bleibt Ihnen keine andere Wahl, als die Daten und die Arbeitslast der größeren Anwendung zu simulieren.
Was gemessen wird Bevor Sie mit dem Benchmarking beginnen, müssen Sie Ihre Ziele festlegen – genauer gesagt, bevor Sie Ihre Benchmarks entwerfen. Ihre Ziele bestimmen die Werkzeuge und Techniken, die Sie einsetzen, um exakte, sinnvolle Ergebnisse zu erhalten. Formulieren Sie Ihre Ziele als Fragen, wie etwa »Ist diese CPU besser als jene?« oder »Funktionieren die neuen Indizes besser als die aktuellen?«.
Benchmarking-Strategien |
37
Es ist vielleicht nicht so offensichtlich, aber manchmal brauchen Sie verschiedene Ansätze, um andere Dinge zu messen. So könnten Latenz und Durchsatz unterschiedliche Benchmarks erfordern. Betrachten Sie die folgenden Maße und wie sie zu Ihren Leistungszielen passen: Transaktionen pro Zeiteinheit Dies ist einer der Klassiker für das Benchmarking von Datenbankanwendungen. Standardisierte Benchmarks wie TPC-C (siehe http://www.tpc.org) sind weithin anerkannt, und viele Datenbankhersteller bemühen sich darum, sie gut zu erfüllen. Diese Benchmarks messen die Leistung bei der Online-Verarbeitung von Transaktionen (Online Transaction Processing; OLTP) und eignen sich am besten für interaktive Mehrbenutzeranwendungen. Die übliche Maßeinheit ist Transaktionen pro Sekunde. Der Begriff Durchsatz bedeutet üblicherweise das Gleiche wie Transaktionen (oder andere Arbeitseinheit) pro Zeiteinheit. Antwortzeit oder Latenz Dies misst die Gesamtzeit, die eine Aufgabe erfordert. Je nach Ihrer Anwendung müssen Sie sie in Millisekunden, Sekunden oder Minuten messen. Von diesem Wert können Sie dann durchschnittliche, minimale und maximale Antwortzeiten ableiten. Die maximale Antwortzeit ist meist kein sinnvolles Maß, da die maximale Antwortzeit wahrscheinlich umso länger wird, je länger der Benchmark läuft. Sie ist außerdem kaum reproduzierbar und wird wahrscheinlich zwischen den Durchläufen stark schwanken. Aus diesem Grund verwenden viele Leute stattdessen die Percentile Response Times (Antwortzeiten der Perzentile). Falls z.B. die Antwortzeit des 95. Perzentils bei 5 Millisekunden liegt, wissen Sie, dass die Aufgabe in 95 % der Fälle in weniger als 5 Millisekunden ausgeführt wird. Meist hilft es, wenn man die Ergebnisse dieser Benchmarks grafisch darstellt, entweder in Form von Linien (z.B. den Durchschnitt und das 95. Perzentil) oder als Streuungsdiagramm, damit Sie sehen können, wie die Werte verteilt sind. Diese Graphen zeigen Ihnen, wie sich die Benchmarks auf lange Sicht verhalten werden. Nehmen Sie einmal an, Ihr System setzt jede Stunde für eine Minute einen Kontrollpunkt. Während der Kontrolle hält das System an, und Transaktionen werden nicht abgeschlossen. Die Antwortzeit des 95. Perzentils zeigt keine Spitzen, die Ergebnisse weisen daher nicht auf das Problem hin. Eine grafische Darstellung dagegen zeigt periodisch auftretende Spitzen in der Antwortzeit. Abbildung 2-1 verdeutlicht dies. Abbildung 2-1 stellt auf der y-Achse die Anzahl der Transaktionen pro Minute dar (ADTPM). Diese Linie zeigt deutliche Spitzen, die im Gesamtdurchschnitt (gepunktete Linie) nicht zu erkennen sind. Die erste Spitze entsteht, weil die Caches des Servers noch leer sind (Cold Cache). Die anderen Spitzen zeigen, wann der Server intensiv »Dirty Pages« auf die Platte schreibt. Ohne das Diagramm sind die Abweichungen schlecht zu erkennen.
38 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
12000 10000
ADTPM
8000 6000 4000 2000 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 Zeit in Minuten
Abbildung 2-1: Ergebnisse eines 30-minütigen dbt2-Benchmark-Durchlaufs
Skalierbarkeit Messungen der Skalierbarkeit sind für solche Systeme sinnvoll, die ihre Leistungsfähigkeit unter sich ändernden Lasten beibehalten sollen. »Performance unter sich ändernder Arbeitslast« ist ein ziemlich abstraktes Konzept. Die Performance wird typischerweise mit einem Maß wie Durchsatz oder Antwortzeit gemessen, die Arbeitslast schwankt bei Änderungen von Datenbankgröße, Anzahl der nebenläufigen Verbindungen oder Hardware. Skalierbarkeitsmessungen bieten sich an, wenn man die Kapazität planen will, da man mit ihnen leicht die Schwächen in der Anwendung zeigen kann, die andere Benchmark-Strategien nicht zeigen. Falls Sie z.B. Ihr System so gestalten, dass es bei einem Antwortzeit-Benchmark mit einer einzigen Verbindung gut funktioniert (eine ziemlich schwache Benchmark-Strategie), wird die Leistung der Anwendung wahrscheinlich stark abfallen, sobald eine bestimmte Anzahl gleichzeitiger Verbindungen erreicht wird. Ein Benchmark, der auf konsistente Antwortzeiten bei einer zunehmenden Anzahl von Verbindungen achtet, würde diesen Entwurfsfehler aufdecken. Manche Aktivitäten, wie etwa Batch-Jobs zum Erzeugen von Zusammenfassungen aus Einzeldaten brauchen einfach schnelle Antwortzeiten, Punkt. Bei ihnen ist es in Ordnung, Benchmarks mit Blick auf die Antwortzeiten durchzuführen; versuchen Sie aber auch daran zu denken, wie sie mit anderen Aktivitäten interagieren. BatchJobs können dafür sorgen, dass interaktive Abfragen leiden und umgekehrt. Nebenläufigkeit Nebenläufigkeit ist ein wichtiges, aber häufig missbrauchtes und falsch verstandenes Maß. Beispielsweise wird gern davon gesprochen, wie viele Benutzer gleichzei-
Benchmarking-Strategien |
39
tig auf einer Website zu Besuch sind. Allerdings ist HTTP zustandslos, und die meisten Benutzer lesen einfach nur, was in ihren Browsern angezeigt wird, das hat also nichts mit Nebenläufigkeit, also der parallelen Abarbeitung auf dem Webserver zu tun. Nebenläufigkeit auf dem Webserver überträgt sich auch nicht unbedingt auf den Datenbankserver; die einzige Sache, mit der sie direkt zusammenhängt, ist die Frage, wie viele Daten der Speichermechanismus der Sitzung verarbeiten können muss. Ein genaueres Maß der Nebenläufigkeit auf dem Webserver ist etwa, wie viele Anforderungen pro Sekunde die Benutzer zu Spitzenzeiten generieren. Sie können Nebenläufigkeit auch an verschiedenen Stellen in der Anwendung messen. Die höhere Nebenläufigkeit auf dem Webserver kann auch eine höhere Nebenläufigkeit auf der Datenbankebene verursachen, das wird allerdings von der Sprache und den verwendeten Werkzeugen beeinflusst. So verursacht z.B. Java mit einem Verbindungspool wahrscheinlich eine geringere Anzahl gleichzeitiger Verbindungen zum MySQL-Server als PHP mit persistenten Verbindungen. Wichtiger ist immer noch die Anzahl der Verbindungen, die zu einem bestimmten Zeitpunkt Abfragen ausführen. Eine gut gestaltete Anwendung könnte Hunderte von Verbindungen zum MySQL-Server offen haben, aber nur ein Bruchteil von ihnen sollte zu einem Zeitpunkt Abfragen ausführen. Eine Website mit »50.000 Benutzern gleichzeitig« bräuchte also nur 10 oder 15 gleichzeitig laufende Abfragen auf dem MySQL-Server! Mit anderen Worten: Worum Sie sich beim Benchmarking wirklich kümmern sollten, ist die Nebenläufigkeit im Betrieb oder die Anzahl der Threads oder Verbindungen, die gleichzeitig aktiv sind. Messen Sie, ob die Leistung stark abfällt, wenn die Nebenläufigkeit zunimmt. Ist dies der Fall, dann kommt Ihre Anwendung mit Lastspitzen nicht zurecht. Sie müssen entweder dafür sorgen, dass die Leistung nicht stark abfällt, oder die Anwendung so gestalten, dass sie in den Teilen, die damit nicht zurechtkommen, keine hohe Nebenläufigkeit zulässt. Im Allgemeinen werden Sie die Nebenläufigkeit auf dem MySQL-Server mit Methoden wie dem Application Queuing beschränken. In Kapitel 10 finden Sie mehr Informationen zu diesem Thema. Nebenläufigkeit ist völlig anders als Antwortzeit und Skalierbarkeit: Es ist kein Ergebnis, sondern eine Eigenschaft dafür, wie Sie den Benchmark einrichten. Anstatt die Nebenläufigkeit zu messen, die Ihre Anwendung erreicht, messen Sie die Leistung der Anwendung auf verschiedenen Ebenen der Nebenläufigkeit. In der letzten Analyse sollten Sie testen, was für Ihre Benutzer wichtig ist. Benchmarks messen die Leistung, aber »Leistung« hat für alle Leute eine andere Bedeutung. Sammeln Sie (offiziell oder inoffiziell) Informationen über die Anforderungen an die Skalierbarkeit des Systems darüber, was als akzeptable Antwortzeiten angesehen wird, welche Art von Nebenläufigkeit erwartet wird usw. Versuchen Sie dann, Ihre Benchmarks so zu gestalten, dass sie all diese Anforderungen berücksichtigen, ohne dass Sie einen Tunnelblick entwickeln oder einige Dinge zum Nachteil anderer bevorzugen.
40 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Benchmarking-Taktiken Nach den allgemeinen Anmerkungen wird es nun spezieller. Wir wollen uns anschauen, wie man Benchmarks gestaltet und ausführt. Zuerst schauen wir uns allerdings einige verbreitete Fehler an, die zu unnützen oder ungenauen Ergebnissen führen können: • die Verwendung einer Teilmenge der echten Datengröße, wie etwa die Verwendung nur eines Gigabyte an Daten, wenn die Anwendung eigentlich Hunderte von Gigabyte verarbeiten können muss, oder die Verwendung der aktuellen Datenmenge, wenn die Anwendung in der Zukunft eigentlich viel größer werden soll • die Verwendung falsch verteilter Daten, wie etwa gleichmäßig verteilter Daten, wenn die Daten des tatsächlichen Systems »Hot Spots« aufweisen (Zufällig generierte Daten weisen oft eine unrealistische Verteilung auf.) • die Verwendung unrealistisch verteilter Parameter, etwa wenn man so tut, als würden alle Benutzerprofile gleich wahrscheinlich betrachtet werden • die Verwendung eines Einbenutzerszenarios für eine Mehrbenutzeranwendung • Benchmarking einer verteilten Anwendung auf einem einzigen Server • falsch eingeschätztes Benutzerverhalten, wie etwa die »Zeit zum Nachdenken« auf einer Webseite. Echte Benutzer fordern eine Seite an und lesen sie dann – sie klicken nicht ohne Pause nacheinander auf Links. • die Ausführung identischer Abfragen in einer Schleife. Echte Abfragen sind nicht identisch, so dass der Cache nicht immer anspringt. Identische Abfragen liegen irgendwann vollständig oder teilweise im Cache vor. • das Verpassen der Fehlerprüfung. Wenn die Ergebnisse eines Benchmarks irgendwie sinnlos sind – z.B., wenn eine langsame Operation auf einmal sehr schnell abgeschlossen wird –, müssen Sie auf Fehler überprüfen. Vielleicht testen Sie mit dem Benchmark ja nur, wie schnell MySQL einen Syntaxfehler in der SQL-Abfrage entdecken kann! Prüfen Sie prinzipiell immer die Fehlerprotokolle nach einem Benchmark-Test. • ignorieren, wie das System läuft, wenn es noch nicht warmgelaufen ist, wie etwa direkt nach einem Neustart. Manchmal müssen Sie wissen, wie lange es dauert, bis der Server nach einem Neustart wieder die volle Kapazität erreicht hat, und schauen sich deshalb speziell die Aufwärmperiode an. Falls Sie andererseits die normale Leistung untersuchen wollen, müssen Sie daran denken, dass viele Caches nach einem Neustart noch kalt sind und die Benchmark-Tests nicht die gleichen Ergebnisse liefern wie nach einer gewissen Laufzeit des Servers. • die Verwendung von Standardservereinstellungen. In Kapitel 6 erfahren Sie mehr über das Optimieren der Servereinstellungen. Schon indem Sie diese Fehler vermeiden, können Sie die Qualität Ihrer Ergebnisse deutlich verbessern.
Benchmarking-Taktiken | 41
Abgesehen davon sollten Sie versuchen, die Tests so realistisch wie möglich zu gestalten. Manchmal allerdings ist es sinnvoll, einen etwas unrealistischen Benchmark einzusetzen. Nehmen Sie z.B. an, Ihre Anwendung befindet sich auf einem anderen Host als der Datenbankserver. Es wäre realistischer, die Benchmarks in der gleichen Konfiguration durchzuführen. Das würde aber gleichzeitig weitere Variablen einbringen, etwa wie schnell und belastet das Netzwerk ist. Benchmarking auf einem einzelnen Knoten ist normalerweise einfacher und in einigen Fällen genau genug. Sie müssen selbst abschätzen, welches Vorgehen passend ist.
Einen Benchmark entwerfen und planen Der erste Schritt beim Planen eines Benchmarks besteht darin, das Problem und das Ziel zu erkennen. Als Nächstes müssen Sie entscheiden, ob Sie einen Standard-Benchmark benutzen oder einen eigenen entwerfen wollen. Wenn Sie einen Standard-Benchmark verwenden, dann achten Sie darauf, dass dieser Ihren Anforderungen entspricht. Nehmen Sie z.B. keinen TPC-Benchmark, um ein ECommerce-System zu testen. Laut eigener Aussage veranschaulicht TPC Entscheidungsunterstützungssysteme, die große Datenmengen untersuchen. Daher ist dieser Benchmark nicht passend für ein OLTP-System. Das Entwerfen eines eigenen Benchmarks ist ein komplizierter und iterativ ablaufender Vorgang. Nehmen Sie als Einstieg einen Schnappschuss Ihrer Produktionsdatenmenge auf. Sorgen Sie dafür, dass Sie diese Daten für nachfolgende Durchläufe wiederherstellen können. Nun brauchen Sie Abfragen, die Sie an diesen Daten durchführen. Sie können eine Modultestsuite in einen rudimentären Benchmark umwandeln, indem Sie sie einfach viele Male durchlaufen lassen. Allerdings wird dies wahrscheinlich kaum der Art und Weise entsprechen, wie Sie die Datenbank wirklich benutzen. Ein besserer Ansatz sieht vor, alle Abfragen auf Ihrem Produktionssystem in einem repräsentativen Zeitrahmen zu protokollieren, etwa eine Stunde unter Spitzenlast oder einen ganzen Tag lang. Wenn Sie Abfragen während eines kurzen Zeitraums aufzeichnen, müssen Sie möglicherweise mehrere Zeitrahmen wählen. Auf diese Weise können Sie alle Systemaktivitäten erfassen, wie etwa Abfragen zur Erstellung von wöchentlichen Berichten oder Batch-Jobs, die Sie außerhalb der Spitzenzeiten eintakten.1 Sie können Abfragen auf unterschiedlichen Ebenen aufzeichnen. Falls Sie z.B. einen FullStack-Benchmark benötigen, können Sie die HTTP-Anforderungen auf einem Webserver protokollieren. Es ist natürlich auch möglich, das MySQL-Abfrage-Log zu aktivieren. Wenn Sie jedoch ein Abfrage-Log noch einmal abspielen, müssen Sie daran denken, die Threads zu trennen, anstatt einfach alle Abfragen linear abzuspielen. Es ist außerdem
1 All das natürlich unter der Voraussetzung, dass Sie einen perfekten Benchmark haben wollen. Normalerweise macht Ihnen das Leben einen Strich durch die Rechnung.
42 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
wichtig, einen eigenen Thread für jede Verbindung in dem Log einzurichten, anstatt die Abfragen in den Threads zu mischen. Das Abfrage-Log zeigt, über welche Verbindungen die einzelnen Abfragen kamen. Selbst wenn Sie keinen eigenen Benchmark herstellen, sollten Sie Ihren BenchmarkingPlan aufschreiben. Sie werden den Benchmark viele Male durchführen und müssen in der Lage sein, ihn exakt zu reproduzieren. Denken Sie bei der Planung auch an die Zukunft. Vielleicht sind Sie gar nicht derjenige, der den Benchmark das nächste Mal ausführt, und selbst wenn, erinnern Sie sich möglicherweise nicht mehr genau daran, wie Sie ihn das erste Mal ausgeführt haben. Ihr Plan sollte auch die Testdaten, die Schritte zum Einrichten des Systems und den Aufwärmplan umfassen. Denken Sie sich eine Methode zum Dokumentieren der Parameter und Ergebnisse aus, und dokumentieren Sie jeden Durchlauf sorgfältig. Ihre Dokumentationsmethode könnte so einfach wie eine Tabellenkalkulation oder ein Notizbuch sein oder so aufwendig wie eine selbst entworfene Datenbank. (Denken Sie daran, dass Sie wahrscheinlich einige Skripte schreiben werden, die Sie bei der Auswertung der Ergebnisse unterstützen. Je einfacher es daher ist, die Ergebnisse zu verarbeiten, ohne Tabellenkalkulations- oder Textdateien zu öffnen, umso besser.) Vermutlich ist es sinnvoll, ein Benchmark-Verzeichnis anzulegen, in dem es Unterverzeichnisse für die Ergebnisse der einzelnen Durchläufe gibt. Sie können dann die Ergebnisse, Konfigurationsdateien und Notizen für jeden Durchlauf in das entsprechende Unterverzeichnis legen. Falls Sie mit Ihrem Benchmark mehr messen, als Sie zunächst interessiert, zeichnen Sie die zusätzlichen Daten dennoch auf. Es ist besser, unnütze Daten zu haben, als wenn wichtige Daten fehlen, und vielleicht brauchen Sie die Zusatzdaten später doch noch. Versuchen Sie, so viele zusätzliche Informationen wie möglich während der Benchmarks aufzuzeichnen, wie etwa CPU-Auslastung, Festplatten-Ein-/ Ausgabe, Statistiken über den Netzwerkverkehr, Zähler von SHOW GLOBAL STATUS usw.
Exakte Ergebnisse erhalten Um wirklich exakte Ergebnisse zu erhalten, müssen Sie Ihren Benchmark so entwerfen, dass er tatsächlich Ihre möglichen Fragen beantwortet. Haben Sie den richtigen Benchmark gewählt? Erfassen Sie alle Daten, die Sie benötigen, um die Fragen zu beantworten? Testen Sie mit dem Benchmark die falschen Kriterien? Führen Sie etwa einen CPUgebundenen Benchmark durch, um die Leistung einer Anwendung vorherzusagen, von der Sie wissen, dass sie ein-/ausgabegebunden ist? Sorgen Sie als Nächstes dafür, dass Ihre Benchmark-Ergebnisse wiederholbar sind. Versuchen Sie sicherzustellen, dass das System sich am Anfang jedes Durchlaufs im gleichen Zustand befindet. Wenn der Benchmark wichtig ist, sollten Sie zwischen den Durchläufen booten. Falls Sie, was normal wäre, einen aufgewärmten Server testen müssen, sollten Sie dafür sorgen, dass die Aufwärmphase lang genug und dass sie wiederholbar ist. Besteht das Aufwärmen z.B. aus zufälligen Abfragen, werden Ihre Benchmark-Ergebnisse nicht reproduzierbar sein. Benchmarking-Taktiken | 43
Wenn der Benchmark Daten oder das Schema ändert, dann setzen Sie ihn zwischen den Durchläufen mit einem frischen Schnappschuss zurück. Das Einfügen in eine Tabelle mit 1000 Zeilen liefert nicht die gleichen Ergebnisse wie das Einfügen in eine Tabelle mit einer Million Zeilen! Auch die Datenfragmentierung und die Aufteilung auf der Festplatte können der Reproduzierbarkeit der Ergebnisse im Wege stehen. Damit das physische Layout immer annähernd gleich ist, könnten Sie eine Partition schnell formatieren und neu mit Daten füllen. Achten Sie auf externe Last-, Profilierungs- und Überwachungssysteme, ausführliches Logging, regelmäßig wiederkehrende Jobs und andere Faktoren, die Ihre Ergebnisse verfälschen können. Eine typische Überraschung ist ein cron-Job, der mitten in einem Benchmark-Durchlauf beginnt, oder ein Patrol-Read-Zyklus oder eine planmäßige Konsistenzprüfung auf Ihrer RAID-Karte. Sorgen Sie dafür, dass alle Ressourcen, die der Benchmark während des Durchlaufs benötigt, auch ihm zugeordnet sind. Wenn jemand anderes die Netzwerkkapazität belegt oder der Benchmark auf einem SAN stattfindet, den auch andere Server benutzen, werden die Ergebnisse möglicherweise nicht genau sein. Versuchen Sie, während der Durchführung eines Benchmarks so wenige Parameter wie möglich zu ändern. Man nennt dies in der Wissenschaft »die Variable isolieren«. Wenn Sie mehrere Dinge auf einmal ändern müssen, dann verpassen Sie vermutlich etwas. Parameter können auch voneinander abhängig sein, so dass sie sich manchmal gar nicht unabhängig voneinander ändern lassen. Vielleicht wissen Sie nicht einmal, dass sie miteinander verbunden sind. Das erhöht natürlich die Komplexität. Manchmal spielt das keine Rolle. Falls Sie etwa über eine Migration von einem Solaris-System auf SPARCHardware zu GNU/Linux auf x86 nachdenken, wäre es sinnlos, als Zwischenschritt Solaris auf x86 einem Benchmark-Test zu unterziehen! Im Allgemeinen hilft es, wenn man die Benchmark-Parameter schrittweise ändert und nicht alle auf einmal. Setzen Sie z.B. Techniken wie »Teile und Herrsche« (zum Halbieren der Unterschiede zwischen den Durchläufen) ein, um sich an einen guten Wert für die Servereinstellung heranzutasten. Wir kennen viele Benchmarks, die versuchen, die Leistung nach einer Migration, etwa von Oracle nach MySQL vorherzusagen. Diese sind oft problematisch, weil MySQLmit völlig anderen Arten von Abfragen gut funktioniert als Oracle. Falls Sie wissen wollen, wie gut eine Anwendung, die auf Oracle erstellt wurde, funktioniert, nachdem Sie sie nach MySQL migriert haben, müssen Sie normalerweise das Schema und die Abfragen für MySQL umgestalten. (In manchen Fällen, z.B. wenn Sie eine plattformübergreifende Anwendung herstellen, wird es Sie interessieren, wie die gleichen Abfragen auf beiden Plattformen laufen, aber das ist eher ungewöhnlich.) Auch aus den vorgegebenen Einstellungen der MySQL-Konfiguration werden Sie kaum sinnvolle Ergebnisse gewinnen, da diese auf winzige Anwendungen abgestimmt sind, die wenig Speicher beanspruchen.
44 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Sollten Sie schließlich ein seltsames Ergebnis erhalten, dann verwerfen Sie es nicht einfach. Versuchen Sie lieber herauszufinden, was passiert ist. Vielleicht finden Sie ein wertvolles Ergebnis, ein großes Problem oder einfach einen Fehler in Ihrem BenchmarkDesign.
Den Benchmark ausführen und die Ergebnisse analysieren Nachdem Sie alles vorbereitet haben, können Sie den Benchmark ausführen und damit beginnen, Daten zu sammeln und zu analysieren. Meist ist es eine gute Idee, die Benchmark-Durchläufe zu automatisieren. Damit verbessern Sie Ihre Ergebnisse und deren Genauigkeit, da Sie auf diese Weise keine Schritte vergessen oder in den einzelnen Durchläufen unterschiedlich ausführen. Es hilft außerdem bei der Dokumentation des Benchmark-Tests. Jede Automatisierungsmethode eignet sich, etwa ein Makefile oder eine Reihe eigener Skripten. Sie können sich für eine beliebige Skriptsprache entscheiden: für eine Shell, PHP, Perl usw. Versuchen Sie, so viel wie möglich zu automatisieren, einschließlich des Ladens der Daten, des Aufwärmens des Systems, des Ausführens des Benchmarks und des Aufzeichnens der Ergebnisse. Wenn Sie das Benchmarking richtig eingerichtet haben, können Sie es in einem Schritt durchführen. Soll es dagegen eine einmalige Angelegenheit bleiben, dann lohnt sich das Automatisieren nicht.
Normalerweise führt man einen Benchmark mehrmals durch. Die genaue Anzahl der Durchgänge hängt von Ihrem Vorgehen bei der Auswertung ab und davon, wie wichtig die Ergebnisse sind. Falls Sie größere Sicherheit haben wollen, müssen Sie den Benchmark mehrfach durchführen. Es ist üblich, das beste Ergebnis zu suchen, einen Durchschnitt aus allen Ergebnissen zu bilden oder den Benchmark fünfmal ablaufen zu lassen und dann den Durchschnitt aus den drei besten Ergebnissen zu bilden. Sie können so exakt sein, wie Sie wollen. Möglicherweise möchten Sie ja statistische Methoden auf Ihre Ergebnisse anwenden, Konfidenzintervalle ermitteln usw., aber oft benötigen Sie diese große Sicherheit gar nicht.2 Wenn er Ihre Fragen zu Ihrer Zufriedenheit beantwortet, können Sie den Benchmark ruhig mehrere Male ausführen und feststellen, wie stark die Ergebnisse sich unterscheiden. Falls sie stark schwanken, führen Sie entweder den Benchmark öfter durch oder lassen ihn länger laufen, wodurch sich normalerweise die Abweichungen verringern. Sobald Sie Ihre Ergebnisse haben, müssen Sie sie analysieren, d.h., Zahlen in Wissen umwandeln. Das Ziel besteht darin, die Frage zu beantworten, die der Benchmark formu-
2 Falls Sie wirklich wissenschaftlich exakte, harte Ergebnisse haben wollen, sollten Sie ein gutes Buch darüber lesen, wie Sie kontrollierte Tests entwerfen und durchführen. Dieses Thema können wir nämlich aufgrund seines Umfangs hier nicht behandeln.
Benchmarking-Taktiken | 45
liert. Idealerweise werden Sie jetzt Aussagen treffen können wie »Das Aufrüsten auf vier CPUs erhöht den Durchsatz um 50 % bei gleichbleibender Latenz« oder »Die Indizes haben die Abfragen beschleunigt«. Wie Sie die Zahlen »würfeln«, hängt davon ab, wie Sie die Ergebnisse gesammelt haben. Es bietet sich an, zur Analyse der Ergebnisse Skripten zu schreiben, nicht nur, um den Arbeitsaufwand zu verringern, sondern aus den gleichen Gründen, aus denen Sie auch die Benchmarks automatisieren sollen: Reproduzierbarkeit und Dokumentation.
Benchmarking-Werkzeuge Sie müssen kein eigenes Benchmarking-System aufziehen. Das ist sowieso nur dann notwendig, wenn es einen wirklich dringenden Grund dafür gibt, dass Sie keines der verfügbaren Systeme einsetzen können. Ihnen stehen eine Vielzahl von Werkzeugen zur Verfügung. In den folgenden Abschnitten werden wir einige davon vorstellen.
Full-Stack-Werkzeuge Erinnern Sie sich daran, dass es zwei Arten von Benchmarks gibt: Full-Stack und SingleComponent. Es wird Sie nicht überraschen zu hören, dass es Werkzeuge gibt, um ganze Anwendungen einem Benchmark-Test zu unterziehen, und Werkzeuge, um an MySQL und anderen Komponenten isoliert Stresstests durchzuführen. Durch das Testen des vollständigen Systems erhalten Sie normalerweise ein klareres Bild von seiner Leistung. Zu den Werkzeugen für solche Tests gehören: ab ab ist ein bekanntes Benchmarking-Werkzeug für den Apache-HTTP-Server. Es zeigt, wie viele Anforderungen pro Sekunde Ihr HTTP-Server bedienen kann. Falls Sie eine Webanwendung testen, bedeutet dies, wie viele Anforderungen pro Sekunde die gesamte Anwendung erfüllen kann. Es ist ein sehr einfaches Werkzeug, sein Nutzen ist allerdings beschränkt, da es einfach nur, so schnell es kann, eine URL abarbeitet. Weitere Informationen über ab finden Sie unter http://httpd.apache. org/docs/2.0/programs/ab.html. http_load Dieses Werkzeug ist vom Konzept her mit ab vergleichbar; es ist ebenfalls dazu gedacht, einen Webserver zu laden, allerdings bietet es größere Flexibilität. Sie können eine Eingabedatei mit vielen verschiedenen URLs anlegen, http_load wählt dann zufällig eine aus. Darüber hinaus können Sie die Rate vorgeben, mit der die Anforderungen ausgeführt werden, anstatt sie einfach so schnell wie möglich abarbeiten zu lassen. Näheres erfahren Sie unter http://www.acme.com/software/http_load/. JMeter JMeter ist ein Java-Programm, das eine andere Anwendung laden und seine Performance messen kann. Es wurde zum Testen von Webanwendungen geschaffen, Sie können damit aber auch FTP-Server testen und über JDBC Abfragen an eine Datenbank auslösen. 46 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
JMeter ist viel komplexer als ab und http_load. Es besitzt z.B. Funktionen, mit denen Sie viel flexibler echte Benutzer simulieren können, indem Sie solche Parameter wie die Anlaufzeit (ramp-up time) kontrollieren. Es verfügt über eine grafische Oberfläche mit einer integrierten Darstellung der Ergebnisse in Diagrammform und bietet die Möglichkeit, Ergebnisse aufzuzeichnen und erneut abzuspielen. Weitere Informationen finden Sie unter http://jakarta.apache.org/jmeter/.
Single-Component-Werkzeuge Hier sind einige nützliche Werkzeuge, um die Leistung von MySQL und des Systems zu testen, auf dem es läuft. Im nächsten Abschnitt zeigen wir Beispiel-Benchmarks mit einigen dieser Werkzeuge: mysqlslap mysqlslap (http://dev.mysql.com/doc/refman/5.1/en/mysqlslap.html) simuliert die Last auf dem Server und liefert Zeitinformationen. Es ist Teil der MySQL-5.1-Server-Distribution, sollte aber auch mit MySQL 4.1 und neueren Servern funktionieren. Sie können angeben, wie viele nebenläufige Verbindungen es benutzen soll, und übergeben entweder eine SQL-Anweisung auf der Kommandozeile oder eine Datei, die auszuführende SQL-Anweisungen enthält. Falls Sie dem Programm keine Anweisungen übergeben, kann es auch automatisch SELECT-Anweisungen generieren, indem es das Schema des Servers untersucht. sysbench sysbench (http://sysbench.sourceforge.net) ist ein Multithread-fähiges System-Benchmarking-Werkzeug. Sein Ziel besteht darin, ein Gefühl für die Systemleistung zu gewinnen, und zwar in Bezug auf Faktoren, die zum Ausführen eines Datenbankservers wichtig sind. Sie können z.B. die Leistung von Datei-Ein-/Ausgabe, Betriebssystem-Scheduler, Speicherzuweisung und Übertragungsgeschwindigkeit, der POSIXThreads sowie des Datenbankservers selbst messen. sysbench unterstützt Skripten in der Sprache Lua (http://www.lua.org), wodurch man sehr flexibel eine Vielzahl von Szenarien testen kann. Database Test Suite Die Database Test Suite, die von den Open-Source Development Labs (OSDL) geschaffen wurde und auf SourceForge unter http://sourceforge.net/projects/osdldbt/ angeboten wird, ist ein Test-Kit zum Ausführen von Benchmarks, die mit einigen Industriestandard-Benchmarks vergleichbar sind, wie etwa denen des Transaction Processing Performance Council (TPC). Speziell beim dbt2-Testprogramm handelt es sich um eine freie (allerdings nicht zertifizierte) Implementierung des TPC-C-OLTPTests. Sie unterstützt InnoDB und Falcon. Zurzeit ist der Status für die anderen transaktionsfähigen MySQL-Storage-Engines unbekannt. MySQL Benchmark Suite (sql-bench) MySQL bietet zusammen mit dem MySQL-Server seine eigene Benchmark-Suite an, mit der Sie unterschiedliche Datenbankserver testen können. Sie ist Single-Thread-
Benchmarking-Werkzeuge |
47
fähig und misst, wie schnell der Server Abfragen ausführt. Die Ergebnisse zeigen, welche Arten von Operationen der Server gut ausführt. Der größte Vorteil dieser Benchmark-Suite besteht darin, dass sie viele vordefinierte Tests enthält, die einfach zu benutzen sind, so dass es leicht ist, unterschiedliche Storage-Engines oder Konfigurationen miteinander zu vergleichen. Man kann damit sogar sehr gut die Gesamtleistung zweier Server miteinander vergleichen. Sie können auch nur einen Teil ihrer Tests ausführen (um z.B. nur die UPDATE-Leistung zu testen). Die Tests sind größtenteils CPU-gebunden, einige kurze Zeiträume erfordern aber auch viele Festplatten-Ein-/Ausgaben. Die größten Nachteile dieses Werkzeugs bestehen darin, dass es nicht mehrbenutzerfähig ist, dass es eine sehr kleine Datenmenge benutzt, dass Sie die Site-spezifischen Daten nicht testen können und dass seine Ergebnisse zwischen den Durchläufen variieren können. Da es nur Single-Thread-fähig und vollständig seriell ist, hilft es Ihnen nicht dabei, die Vorteile mehrerer CPUs abzuschätzen. Allerdings lassen sich mehrere Server mit jeweils nur einer CPU miteinander vergleichen. Für den Datenbankserver, den Sie testen wollen, sind Perl- und DBD-Treiber erforderlich. Die Dokumentation finden Sie unter http://dev.mysql.com/doc/en/mysqlbenchmarks.html/. Super Smack Super Smack (http://vegan.net/tony/supersmack/) ist ein Stresstest-Werkzeug für MySQL und PostgreSQL. Es handelt sich hierbei um ein komplexes, leistungsfähiges Werkzeug, mit dem Sie mehrere Benutzer simulieren, Testdaten in die Datenbank laden und Tabellen mit zufällig generierten Daten füllen können. Die Benchmarks sind in sogenannten »Smack«-Dateien enthalten, die eine einfache Sprache verwenden, um Clients, Tabellen, Abfragen usw. zu definieren.
Benchmarking-Beispiele In diesem Abschnitt zeigen wir Ihnen einige Beispiele für tatsächliche Benchmarks mit einigen der oben erwähnten Werkzeuge. Wir können nicht auf jedes Werkzeug ausführlich eingehen, aber dennoch sollten Ihnen diese Beispiele bei der Entscheidung für einen sinnvollen Benchmark und bei den ersten Schritten helfen.
http_load Beginnen wir mit einem einfachen Beispiel für die Verwendung von http_load. Dazu benutzen wir die folgenden URLs, die wir in der Datei urls.txt gespeichert haben: http://www.mysqlperformanceblog.com/ http://www.mysqlperformanceblog.com/page/2/ http://www.mysqlperformanceblog.com/mysql-patches/ http://www.mysqlperformanceblog.com/mysql-performance-presentations/ http://www.mysqlperformanceblog.com/2006/09/06/slow-query-log-analyzes-tools/
48 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Die MySQL-Funktion BENCHMARK( ) MySQL besitzt eine praktische BENCHMARK( )-Funktion, mit der Sie die Ausführungsgeschwindigkeit bestimmter Arten von Operationen testen können. Sie geben einen Ausdruck an, der ausgeführt werden soll, und legen fest, wie oft dies zu geschehen hat. Der Ausdruck kann ein beliebiger Skalar sein, wie etwa eine skalare Unterabfrage oder eine Funktion. Damit lässt sich sehr schön die relative Geschwindigkeit einiger Operationen testen, wie etwa ob MD5( ) schneller als SHA1( ) ist: mysql> SET @input := 'hello world'; mysql> SELECT BENCHMARK(1000000, MD5(@input)); +---------------------------------+ | BENCHMARK(1000000, MD5(@input)) | +---------------------------------+ | 0 | +---------------------------------+ 1 row in set (2.78 sec) mysql> SELECT BENCHMARK(1000000, SHA1(@input)); +----------------------------------+ | BENCHMARK(1000000, SHA1(@input)) | +----------------------------------+ | 0 | +----------------------------------+ 1 row in set (3.50 sec)
Der Rückgabewert ist immer 0. Sie messen die Ausführung, indem Sie nachschauen, welche Zeit die Clientanwendung für die Ausführung der Abfrage angegeben hat. In diesem Fall sieht es so aus, als sei MD5( ) schneller. Es ist allerdings nicht ganz einfach, BENCHMARK( ) richtig einzusetzen, wenn man nicht weiß, was es eigentlich tut. Es misst nämlich, wie schnell der Server den Ausdruck ausführen kann, liefert jedoch keinen Hinweis auf den Overhead für das Parsen und Optimieren. Und wenn der Ausdruck keine Benutzervariable enthält, dann wird unter Umständen ab der zweiten Ausführung des Ausdrucks durch den Server ein Ergebnis aus dem Cache zurückgeliefert.3 Auch wenn es praktisch ist, verwenden wir BENCHMARK( ) nicht für echte Benchmarks. Es ist einfach zu schwer festzustellen, was es wirklich misst, und beschränkt sich außerdem zu sehr auf einen kleinen Teil des gesamten Ausführungsprozesses.
Am einfachsten benutzt man http_load, indem man die URLs in einer Schleife abruft. Das Programm ruft sie so schnell wie möglich auf:3 $ http_load -parallel 1 -seconds 10 urls.txt 19 fetches, 1 max parallel, 837929 bytes, in 10.0003 seconds 44101.5 mean bytes/connection 1.89995 fetches/sec, 83790.7 bytes/sec msecs/connect: 41.6647 mean, 56.156 max, 38.21 min 3 Einer der Autoren machte diesen Fehler und stellte fest, dass 10.000 Ausführungen eines bestimmten Ausdrucks genauso schnell liefen wie eine Ausführung. Es war ein Cache-Ergebnis. Im Allgemeinen müssen Sie bei einem solchen Verhalten immer von einem Cache-Ergebnis oder einem Fehler ausgeben.
Benchmarking-Beispiele | 49
msecs/first-response: 320.207 mean, 508.958 max, 179.308 min HTTP response codes: code 200 – 19
Die Ergebnisse sind eigentlich selbsterklärend: Sie zeigen einfach Statistiken über die Anforderungen. Ein etwas komplexeres Benutzungsszenario sieht vor, dass die URLs so schnell wie möglich in einer Schleife abgerufen, damit aber fünf gleichzeitig agierende Benutzer emuliert werden: $ http_load -parallel 5 -seconds 10 urls.txt 94 fetches, 5 max parallel, 4.75565e+06 bytes, in 10.0005 seconds 50592 mean bytes/connection 9.39953 fetches/sec, 475541 bytes/sec msecs/connect: 65.1983 mean, 169.991 max, 38.189 min msecs/first-response: 245.014 mean, 993.059 max, 99.646 min HTTP response codes: code 200 – 94
Alternativ können wir, anstatt die URLs so schnell wie möglich abzurufen, die Last für eine vorherbestimmte Anforderungsrate (wie etwa fünf pro Sekunde) emulieren: $ http_load -rate 5 -seconds 10 urls.txt 48 fetches, 4 max parallel, 2.50104e+06 bytes, in 10 seconds 52105 mean bytes/connection 4.8 fetches/sec, 250104 bytes/sec msecs/connect: 42.5931 mean, 60.462 max, 38.117 min msecs/first-response: 246.811 mean, 546.203 max, 108.363 min HTTP response codes: code 200 – 48
Schließlich emulieren wir eine noch größere Last mit einer Rate von 20 eingehenden Anforderungen pro Sekunde. Beachten Sie, dass die Verbindungs- und Antwortraten mit höherer Last zunehmen: $ http_load -rate 20 -seconds 10 urls.txt 111 fetches, 89 max parallel, 5.91142e+06 bytes, in 10.0001 seconds 53256.1 mean bytes/connection 11.0998 fetches/sec, 591134 bytes/sec msecs/connect: 100.384 mean, 211.885 max, 38.214 min msecs/first-response: 2163.51 mean, 7862.77 max, 933.708 min HTTP response codes: code 200 -- 111
sysbench Das Programm sysbench kann eine Vielzahl von Benchmarks ausführen, die es als »Tests« bezeichnet. Es soll nicht nur die Datenbankleistung testen, sondern auch, wie gut ein System wahrscheinlich als Datenbankserver arbeiten wird. Wir beginnen mit einigen Tests, die nicht MySQL-spezifisch sind, und messen die Leistung für Subsysteme, die die Gesamtgrenzen des Systems bestimmen. Anschließend zeigen wir, wie die Datenbankleistung gemessen wird.
50 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Der sysbench-CPU-Benchmark Der offensichtlichste Subsystemtest ist der CPU-Benchmark, der 64-Bit-Integer-Werte verwendet, um Primzahlen bis zu einem angegebenen Maximalwert zu berechnen. Wir führen diesen Test auf zwei Servern aus, die beide unter GNU/Linux laufen, und vergleichen die Ergebnisse miteinander. Hier sehen Sie die Hardware des ersten Servers: [server1 ~]$ cat /proc/cpuinfo ... model name : AMD Opteron(tm) Processor 246 stepping : 1 cpu MHz : 1992.857 cache size : 1024 KB
Und so führen wir den Benchmark aus: [server1 ~]$ sysbench --test=cpu --cpu-max-prime=20000 run sysbench v0.4.8: multi-threaded system evaluation benchmark ... Test execution summary: total time: 121.7404s
Der zweite Server besitzt eine andere CPU: [server2 ~]$ cat /proc/cpuinfo ... model name : Intel(R) Xeon(R) CPU stepping : 6 cpu MHz : 1995.005
5130
@ 2.00GHz
Hier ist sein Benchmark-Ergebnis: [server1 ~]$ sysbench --test=cpu --cpu-maxprime=20000 run sysbench v0.4.8: multi-threaded system evaluation benchmark ... Test execution summary: total time: 61.8596s
Das Ergebnis zeigt einfach die Gesamtzeit an, die erforderlich war, um die Primzahlen zu berechnen. Das lässt sich ganz leicht vergleichen. In diesem Fall führte der zweite Server den Benchmark fast doppelt so schnell aus wie der erste Server.
Der sysbench-Datei-Ein-/Ausgabe-Benchmark Der fileio-Benchmark misst, wie Ihr System unter verschiedenen Arten von Ein-/Ausgabe-Lasten arbeitet. Damit kann man Festplatten, RAID-Karten und RAID-Modi vergleichen und das Ein-/Ausgabe-Subsystem anpassen und verbessern. Zuerst müssen einige Dateien für den Benchmark vorbereitet werden. Sie sollten deutlich mehr Daten generieren, als in den Speicher passen. Passen die Daten komplett in den Speicher, schiebt das Betriebssystem die meisten von ihnen in den Cache, und das Ergebnis spiegelt die ein-/ausgabegebundene Last nicht korrekt wider. Wir erzeugen zuerst eine Datenmenge: $ sysbench --test=fileio --file-total-size=150G prepare
Benchmarking-Beispiele | 51
Im zweiten Schritt wird der Benchmark ausgeführt. Zum Testen verschiedener Arten von Ein-/Ausgabe-Leistung stehen mehrere Optionen zur Verfügung: seqwr
Sequenzielles Schreiben seqrewr
Sequenzielles Neuschreiben seqrd
Sequenzielles Lesen rndrd
Zufälliges Lesen rndwr
Zufälliges Schreiben rndrw
Kombiniertes zufälliges Lesen/Schreiben Der folgende Befehl führt den Benchmark mit zufälligem Lese-/Schreibzugriff aus: $ sysbench --test=fileio --file-total-size=150G --file-test-mode=rndrw --init-rnd=on --max-time=300 --max-requests=0 run
Hier sind die Ergebnisse: sysbench v0.4.8:
multi-threaded system evaluation benchmark
Running the test with following options: Number of threads: 1 Initializing random number generator from timer. Extra file open flags: 0 128 files, 1.1719Gb each 150Gb total file size Block size 16Kb Number of random requests for random IO: 10000 Read/Write ratio for combined random IO test: 1.50 Periodic FSYNC enabled, calling fsync( ) each 100 requests. Calling fsync( ) at the end of test, Enabled. Using synchronous I/O mode Doing random r/w test Threads started! Time limit exceeded, exiting... Done. Operations performed: 40260 Read, 26840 Write, 85785 Other = 152885 Total Read 629.06Mb Written 419.38Mb Total transferred 1.0239Gb (3.4948Mb/sec) 223.67 Requests/sec executed Test execution summary: total time: 300.0004s total number of events: 67100 total time taken by event execution: 254.4601 per-request statistics:
52 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
min: avg: max: approx. 95 percentile: Threads fairness: events (avg/stddev): execution time (avg/stddev):
0.0000s 0.0038s 0.5628s 0.0099s
67100.0000/0.00 254.4601/0.00
Die Ausgabe enthält eine Menge an Informationen. Die interessantesten Zahlen zum Verfeinern des Ein-/Ausgabe-Subsystems sind die Anzahl der Anforderungen pro Sekunde und der Gesamtdurchsatz. In diesem Fall zeigen die Ergebnisse 223,67 Anforderungen/Sekunde bzw. 3,4948 MByte/Sekunde. Diese Werte liefern einen guten Hinweis auf die Performance der Festplatten. Wenn Sie fertig sind, löschen Sie die Dateien, die sysbench für die Benchmarks angelegt hat: $ sysbench --test=fileio –-file-total-size=150G cleanup
Der sysbench-OLTP-Benchmark Der OLTP-Benchmark emuliert die Last bei der Transaktionsverarbeitung. Wir zeigen ein Beispiel mit einer Tabelle, die eine Million Zeilen enthält. Der erste Schritt besteht darin, die Tabelle für den Test vorzubereiten: $ sysbench --test=oltp --oltp-table-size=1000000 --mysql-db=test --mysqluser=root prepare sysbench v0.4.8: multi-threaded system evaluation benchmark No DB drivers specified, using mysql Creating table 'sbtest'... Creating 1000000 records in table 'sbtest'...
Das war schon die gesamte Vorbereitung. Nun lassen wir den Benchmark 60 Sekunden lang mit 8 nebenläufigen Threads im Read-Only-Modus laufen: $ sysbench --test=oltp --oltp-table-size=1000000 --mysql-db=test --mysql-user=root --maxtime=60 --oltp-read-only=on --max-requests=0 --num-threads=8 run sysbench v0.4.8: multi-threaded system evaluation benchmark No DB drivers specified, using mysql WARNING: Preparing of "BEGIN" is unsupported, using emulation (last message repeated 7 times) Running the test with following options: Number of threads: 8 Doing OLTP test. Running mixed OLTP test Doing read-only test Using Special distribution (12 iterations, Using "BEGIN" for starting transactions Using auto_inc on the id column Threads started!
1 pct of values are returned in 75 pct cases)
Benchmarking-Beispiele | 53
Time limit exceeded, exiting... (last message repeated 7 times) Done. OLTP test statistics: queries performed: read: write: other: total: transactions: deadlocks: read/write requests: other operations:
179606 0 25658 205264 12829 0 179606 25658
Test execution summary: total time: total number of events: total time taken by event execution: per-request statistics: min: avg: max: approx. 95 percentile: Threads fairness: events (avg/stddev): execution time (avg/stddev):
(213.07 per sec.) (0.00 per sec.) (2982.92 per sec.) (426.13 per sec.)
60.2114s 12829 480.2086 0.0030s 0.0374s 1.9106s 0.1163s
1603.6250/70.66 60.0261/0.06
Wie gehabt finden Sie auch hier viele Informationen in den Ergebnissen. Die interessantesten Teile sind: • der Transaktionszähler • die Rate der Transaktionen pro Sekunde • die Statistiken für die einzelnen Anforderungen (minimale, durchschnittliche und maximale Zeit sowie die Zeit des 95. Perzentils) • Statistiken für die Thread-Fairness, die zeigen, wie fair die simulierte Last war
Weitere sysbench-Funktionen Das sysbench-Programm kann verschiedene weitere System-Benchmarks ausführen, die nicht direkt die Leistung eines Datenbankservers messen: memory
Führt sequenzielle Speicher-Lese- oder Schreiboperationen aus. threads
Misst die Performance des Thread-Schedulers. Damit kann man vor allem das Verhalten des Schedulers unter hoher Last testen.
54 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
mutex
Misst die Mutex-Leistung, indem eine Situation emuliert wird, in der meist alle Threads parallel ablaufen, wobei nur kurzzeitig Mutex-Locks geholt werden. (Bei einem Mutex handelt es sich um eine Datenstruktur, die einen Zugriff unter wechselseitigem Ausschluss [engl. Mutual Exclusive] auf eine Ressource garantiert, so dass verhindert wird, dass ein nebenläufiger Zugriff Probleme verursacht.) seqwr
Misst die Leistung bei sequenziellen Schreiboperationen. Dies ist sehr wichtig, um die praktischen Leistungsgrenzen eines Systems zu testen. Es kann zeigen, wie gut der Cache Ihres RAID-Controllers funktioniert, und alarmiert Sie, wenn die Ergebnisse ungewöhnlich ausfallen. Falls Sie z.B. keinen batteriegesicherten SchreibCache haben, Ihre Platte aber 3.000 Anforderungen pro Sekunde erhält, dann stimmt etwas nicht und Ihre Daten sind nicht mehr sicher. Zusätzlich zum Benchmark-spezifischen Parameter (--test) akzeptiert sysbench weitere gebräuchliche Parameter, wie etwa --num-threads, --max-requests und --max-time. In der Dokumentation finden Sie Informationen dazu.
dbt2 TPC-C auf der Database Test Suite Das dbt2-Werkzeug der Database Test Suite ist eine freie Implementierung des TPC-CTests. TPC-C ist eine Spezifikation, die vom TPC (Transaction Processing Performing Council) veröffentlicht wurde und eine komplexe Online-Transaktionsverarbeitungslast emuliert. Es weist seine Ergebnisse in Transaktionen pro Minute (tpmC) aus, zusammen mit den Kosten für die einzelnen Transaktionen (Preis/tpmC). Die Ergebnisse hängen stark von der Hardware ab, weshalb veröffentlichte TPC-C-Ergebnisse ausführliche Spezifikationen der Server enthalten, die in dem Benchmark verwendet wurden. Der dbt2-Test ist eigentlich nicht TPC-C. Er ist nicht vom TPC zertifiziert, und seine Ergebnisse können auch nicht direkt mit TPC-C-Ergebnissen verglichen werden.
Schauen wir uns ein Beispiel für das Einrichten und Ausführen eines dbt2-Benchmarks an. Wir haben Version 0.37 von dbt2 verwendet. Das ist die neueste Version, die wir zusammen mit MySQL einsetzen konnten (neuere Versionen enthalten Erweiterungen, die MySQL nicht vollständig unterstützt). Wir haben folgende Schritte unternommen: 1. Vorbereitung der Daten
Der folgende Befehl erzeugt Daten für 10 Warehouses in dem angegebenen Verzeichnis. Die Warehouses nehmen zusammen einen Platz von etwa 700 MByte ein. Der erforderliche Platzbedarf ändert sich proportional zur Anzahl der Warehouses, Sie können also den Parameter -w ändern, um eine Datenmenge mit der von Ihnen benötigten Größe anzulegen.
Benchmarking-Beispiele | 55
# src/datagen -w 10 -d /mnt/data/dbt2-w10 warehouses = 10 districts = 10 customers = 3000 items = 100000 orders = 3000 stock = 100000 new_orders = 900 Output directory of data files: /mnt/data/dbt2-w10 Generating data files for 10 warehouse(s)... Generating item table data... Finished item table data... Generating warehouse table data... Finished warehouse table data... Generating stock table data...
2. Laden der Daten in die MySQL-Datenbank
Der nächste Befehl erzeugt eine Datenbank namens dbt2w10 und lädt in sie die Daten, die wir im vorhergehenden Schritt erzeugt haben (-d ist der Datenbankname, und -f ist das Verzeichnis mit den generierten Daten): # scripts/mysql/mysql_load_db.sh -d dbt2w10 -f /mnt/data/dbt2-w10 s /var/lib/mysql/mysql.sock
3. Ausführen des Benchmarks
Im letzten Schritt wird der folgende Befehl aus dem Verzeichnis scripts ausgeführt: # run_mysql.sh -c 10 -w 10 -t 300 -n dbt2w10 -u root -o /var/lib/mysql/mysql.sock -e ************************************************************************ * DBT2 test for MySQL started * * * * Results can be found in output/9 directory * ************************************************************************ * * * Test consists of 4 stages: * * * * 1. Start of client to create pool of databases connections * * 2. Start of driver to emulate terminals and transactions generation * * 3. Test * * 4. Processing of results * * * ************************************************************************ DATABASE NAME: DATABASE USER: DATABASE SOCKET: DATABASE CONNECTIONS: TERMINAL THREADS: SCALE FACTOR(WARHOUSES): TERMINALS PER WAREHOUSE: DURATION OF TEST(in sec): SLEEPY in (msec) ZERO DELAYS MODE:
56 |
dbt2w10 root /var/lib/mysql/mysql.sock 10 100 10 10 300 300 1
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Stage 1. Starting up client... Delay for each thread 300 msec. Will sleep for 4 sec to start 10 database connections CLIENT_PID = 12962 Stage 2. Starting up driver... Delay for each thread 300 msec. Will sleep for 34 sec to start 100 terminal threads All threads has spawned successfuly. Stage 3. Starting of the test. Duration of the test 300 sec Stage 4. Processing of results... Shutdown clients. Send TERM signal to 12962. Response Time (s) Transaction % Average : 90th % Total ------------ ----- ----------------- -----Delivery 3.53 2.224 : 3.059 1603 New Order 41.24 0.659 : 1.175 18742 Order Status 3.86 0.684 : 1.228 1756 Payment 39.23 0.644 : 1.161 17827 Stock Level 3.59 0.652 : 1.147 1630
Rollbacks --------0 172 0 0 0
% ----0.00 0.92 0.00 0.00 0.00
3396.95 new-order transactions per minute (NOTPM) 5.5 minute duration 0 total unknown errors 31 second(s) ramping up
Das wichtigste Ergebnis ist diese Zeile kurz vor dem Ende: 3396.95 new-order transactions per minute (NOTPM)
Sie zeigt uns, wie viele Transaktionen pro Minute das System verarbeiten kann – je mehr, desto besser. (Der Begriff »new-order« steht nicht für eine bestimmte Art von Transaktion, sondern bedeutet einfach, dass der Test jemanden simuliert hat, der eine neue Bestellung auf der imaginären E-Commerce-Website abgegeben hat.) Sie können einige der Parameter ändern, um andere Benchmarks zu erzeugen: -c
-e
-t
Die Anzahl der Verbindungen zur Datenbank. Sie können dies ändern, um unterschiedliche Nebenläufigkeitsstufen zu emulieren und festzustellen, wie das System skaliert. Dies aktiviert den Zero-Delay-Modus, was bedeutet, dass es zwischen den Abfragen keine Verzögerungen gibt. Das ist ein Stresstest für die Datenbank, der aber in gewisser Weise unrealistisch ist, da echte Benutzer Zeit zum Nachdenken benötigen, bevor sie neue Abfragen generieren. Die Gesamtdauer des Benchmarks. Wählen Sie diese Zeit sorgfältig, da Ihre Ergebnisse ansonsten keine Bedeutung haben. Eine zu kurze Zeit für den Benchmark-Test einer ein-/ausgabegebundenen Last liefert unkorrekte Ergebnisse, da das System nicht genug Zeit hat, um die Caches zu füllen und eine normale Arbeit zu beginnen. Falls Sie andererseits eine CPU-gebundene Last einem Benchmark unterziehen wollen, dürfen Sie die Zeit nicht zu lang wählen, da sonst die Datenmenge möglicherweise zu stark anwächst und ein-/ausgabegebunden wird. Benchmarking-Beispiele | 57
Die Ergebnisse dieses Benchmarks können Informationen über mehr als nur die Performance liefern. Falls Sie z.B. zu viele Rollbacks sehen, wissen Sie, dass wahrscheinlich etwas nicht stimmt.
Die MySQL-Benchmark-Suite Die MySQL-Benchmark-Suite besteht aus einem Satz von Perl-Benchmarks; Sie brauchen also Perl, um sie auszuführen. Sie finden die Benchmarks im Unterverzeichnis sql-bench/ Ihrer MySQL-Installation. Auf Debian GNU/Linux-Systemen befinden sie sich z.B. in /usr/share/mysql/sql-bench/. Bevor Sie beginnen, lesen Sie die mitgelieferte README-Datei, in der erläutert wird, wie die Suite benutzt wird, und die die Kommandozeilenargumente dokumentiert. Um alle Tests auszuführen, verwenden Sie solche Befehle: $ cd /usr/share/mysql/sql-bench/ sql-bench$ ./run-all-tests --server=mysql --user=root --log --fast Test finished. You can find the result in: output/RUN-mysql_fast-Linux_2.4.18_686_smp_i686
Die Ausführung der Benchmarks kann, je nach verwendeter Hardware und Konfiguration, länger als eine Stunde dauern. Wenn Sie die Kommandozeilenoption --log angeben, dann können Sie den Fortschritt während der Abarbeitung beobachten. Die Tests schreiben ihre Ergebnisse in ein Unterverzeichnis namens output. Jede Datei besteht aus einer Reihe von Zeitangaben für die Operationen in dem jeweiligen Benchmark. Hier ist ein Ausschnitt, der für den Druck nur ein wenig schöner formatiert wurde: sql-bench$ tail -5 output/select-mysql_fast-Linux_2.4.18_686_smp_i686 Time for count_distinct_group_on_key (1000:6000): 34 wallclock secs ( 0.20 usr 0.08 sys + 0.00 cusr 0.00 csys = 0.28 Time for count_distinct_group_on_key_parts (1000:100000): 34 wallclock secs ( 0.57 usr 0.27 sys + 0.00 cusr 0.00 csys = 0.84 Time for count_distinct_group (1000:100000): 34 wallclock secs ( 0.59 usr 0.20 sys + 0.00 cusr 0.00 csys = 0.79 Time for count_distinct_big (100:1000000): 8 wallclock secs ( 4.22 usr 2.20 sys + 0.00 cusr 0.00 csys = 6.42 Total time: 868 wallclock secs (33.24 usr 9.55 sys + 0.00 cusr 0.00 csys = 42.79
CPU) CPU) CPU) CPU) CPU)
Der count_distinct_group_on_key (1000:6000)-Test brauchte z.B. für die Ausführung 34 »Wall-Clock-Sekunden« (also echte Sekunden). Das ist die Gesamtzeit, die der Client für die Ausführung des Tests benötigte. Die anderen Werte (usr, sys, cursr, csys), die sich zu 0,28 aufsummiert haben, geben den Overhead für diesen Test an. So viel Zeit wurde also zum Ausführen des Client-Codes aufgebracht, anstatt auf die Antwort des MySQL-Servers zu warten. Der für uns interessante Wert – also die Zeit, die mit Dingen verbracht wurde, die nicht der Kontrolle des Clients unterliegen – beträgt daher 33,72 Sekunden. Statt der gesamten Suite können Sie die Tests auch einzeln ausführen. Vielleicht wollen Sie sich z.B. auf den Insert-Test konzentrieren. Dieser bietet Ihnen mehr Details als die Zusammenfassung, die von der kompletten Test-Suite erzeugt wird:
58 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
sql-bench$ ./test-insert Testing server 'MySQL 4.0.13 log' at 2003-05-18 11:02:39 Testing the speed of inserting data into 1 table and do some selects on it. The tests are done with a table that has 100000 rows. Generating random keys Creating tables Inserting 100000 rows in order Inserting 100000 rows in reverse order Inserting 100000 rows in random order Time for insert (300000): 42 wallclock secs ( 7.91 usr 5.03 sys + Testing insert of duplicates Time for insert_duplicates (100000): 16 wallclock secs ( 2.28 usr 1.89 sys +
0.00 cusr
0.00 csys = 12.94 CPU)
0.00 cusr
0.00 csys =
4.17 CPU)
Profiling Beim Profiling erfahren Sie, wie stark die einzelnen Teile eines Systems zu den Gesamtkosten beitragen, die zum Herstellen eines Ergebnisses nötig sind. Das einfachste Maß für die Kosten ist die Zeit. Beim Profiling kann aber auch die Anzahl der Funktionsaufrufe, Ein-/Ausgabe-Operationen, Datenbankabfragen usw. gemessen werden. Das Ziel besteht darin, zu verstehen, weshalb ein System so arbeitet, wie es das tut.
Eine Anwendung profilieren Wie beim Benchmarking können Sie ein Profil auf Anwendungsebene oder auf einer einzelnen Komponente, wie dem MySQL-Server, erstellen. Ein Profiling auf Anwendungsebene liefert normalerweise eine bessere Einsicht in die Frage, wie man die Anwendung optimieren kann, und stellt genauere Ergebnisse bereit, da die Ergebnisse die Arbeit umfassen, die von der gesamten Anwendung geleistet wurde. Falls Sie etwa die MySQLAbfragen der Anwendung optimieren wollen, werden Sie möglicherweise versucht sein, die Abfragen auszuführen und zu analysieren. In diesem Fall verpassen Sie allerdings viele wichtige Informationen über die Abfragen, wie etwa Einblicke in die Arbeit, die die Anwendung erledigen muss, wenn die Ergebnisse in den Speicher gelesen und verarbeitet werden.4 Da Webanwendungen einen sehr verbreiteten Anwendungsfall für MySQL darstellen, verwenden wir eine PHP-Website als Beispiel. Typischerweise müssen Sie die Anwendung global profilieren, um festzustellen, wie das System geladen wurde. Vielleicht wol-
4 Wenn Sie einen Engpass untersuchen, dann können Sie das möglicherweise abkürzen und feststellen, wo er liegt, indem Sie einige grundlegende Systemstatistiken unter die Lupe nehmen. Falls die Webserver untätig sind und der MySQL-Server 100 % der CPU nutzt, müssen Sie wahrscheinlich nicht die gesamte Anwendung profilieren, vor allem, wenn es dringend ist. Die ganze Anwendung können Sie sich immer noch anschauen, nachdem Sie die Krise überwunden haben.
Profiling | 59
len Sie aber auch einige interessante Subsysteme isolieren, wie etwa die Suchfunktion. Jedes teure, d.h. aufwendige Subsystem bildet einen guten Kandidaten für ein isoliertes Profiling. Wenn wir optimieren müssen, wie eine PHP-Website MySQL verwendet, dann ziehen wir es vor, Statistiken über die Granularität der Objekte (oder Module) im PHP-Code zu sammeln. Das Ziel besteht darin, zu messen, wie viel der Antwortzeit der einzelnen Seiten von den Datenbankoperationen verbraucht wird. Der Zugriff auf die Datenbank stellt in Anwendungen oft, aber nicht immer, den Flaschenhals dar. Flaschenhälse können auch von folgenden Faktoren verursacht werden: • externen Ressourcen, wie etwa Aufrufen an Webservices oder Suchmaschinen • Operationen, die die Verarbeitung großer Datenmengen in der Anwendung erfordern, wie etwa das Parsen großer XML-Dateien • aufwendigen Operationen in engen Schleifen, wie beim Missbrauch von regulären Ausdrücken • schlecht optimierten Algorithmen, wie etwa naiven Suchalgorithmen zum Suchen von Objekten in Listen Bevor Sie sich MySQL-Abfragen anschauen, müssen Sie die tatsächliche Quelle Ihrer Performance-Probleme ermitteln. Das Profiling von Anwendungen kann Sie bei der Suche nach Engpässen unterstützen und ist ein wichtiger Schritt bei der Überwachung und Verbesserung der Gesamtleistung.
Wie und was gemessen wird Für die meisten Anwendungen ist die Zeit ein gutes Maß für das Profiling, da die meisten Benutzer sich am meisten um die Zeit sorgen. Bei Webanwendungen benutzen wir gern einen Debug-Modus, der für jede Seite die Abfragen zusammen mit ihren Zeiten und der Anzahl der Zeilen anzeigt. Bei langsamen Abfragen können wir dann EXPLAIN ausführen (in späteren Kapiteln finden Sie weitere Informationen über EXPLAIN). Zur genaueren Analyse kombinieren wir diese Daten mit Maßen vom MySQL-Server. Wir empfehlen Ihnen, in jedes neue Projekt, das Sie beginnen, Profiling-Code aufzunehmen. Bei bestehenden Anwendungen mag es schwierig sein, in eine neue Anwendung können Sie dagegen leicht Profiling-Code einbinden. Viele Bibliotheken enthalten Funktionen, die das erleichtern. So besitzen etwa Javas JDBC und PHPs mysqli Funktionen für das Profiling des Datenbankzugriffs. Profiling-Code ist darüber hinaus ausgesprochen sinnvoll zum Verfolgen seltsamer Probleme, die nur im Betrieb auftreten und in der Entwicklung nicht reproduziert werden können. Ihr Profiling-Code sollte wenigstens die folgenden Daten sammeln und protokollieren: • die Gesamtausführungszeit oder »Wall-Clock«-Zeit (Bei Webanwendungen ist das die Gesamtzeit zum Seitenaufbau.)
60 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
• jede ausgeführte Abfrage sowie deren Ausführungszeit • jede Verbindung, die zum MySQL-Server geöffnet wurde • jeden Aufruf einer externen Ressource, wie etwa von Webservices, memcached und extern ausgeführten Skripten • potenziell teure Funktionsaufrufe, wie etwa XML-Analysen • Benutzer- und System-CPU-Zeit Mit diesen Informationen können Sie die Leistung besser überwachen. Sie liefern Ihnen Einblicke in die Performance, die Sie sonst nur schwer erlangen können, wie etwa: • • • •
globale Leistungsprobleme sporadisch erhöhte Antwortzeiten Systemengpässe, die nicht bei MySQL liegen müssen Ausführungszeiten »unsichtbarer« Benutzer, wie etwa der Spider von Suchmaschinen
Bremst Profiling Ihre Server? Ja. Profiling und routinemäßige Überwachung erhöhen den Overhead. Die wichtigen Fragen lauten, wie viel Overhead sie hinzufügen und ob der Vorteil den zusätzlichen Aufwand rechtfertigt. Viele Leute, die leistungsstarke Anwendungen entwerfen und herstellen, glauben, dass man alles messen muss, was messbar ist, und dass man die Kosten des Messens einfach als Teil der Arbeit der Anwendung akzeptieren sollte. Selbst wenn Sie dem nicht zustimmen, ist es doch eine gute Idee, wenigstens eine Art von leichtem Profiling hinzuzufügen, das Sie permanent aktivieren können. Es ist schließlich nicht lustig, auf einen Leistungsengpass zu treffen, den Sie nicht kommen sahen, weil Ihre Systeme nicht darauf ausgelegt sind, täglich auftretende Leistungsänderungen zu erfassen. Wenn Ihnen ein Problem auffällt, können historische Daten von unschätzbarem Wert sein. Mithilfe von Profiling-Daten ist es sogar möglich, Hardware-Anschaffungen zu planen, Ressourcen zuzuweisen und die Last für Spitzenzeiten vorherzusagen. Was meinen wir mit »leichtem« Profiling? Das Aufzeichnen der Zeiten für die SQL-Abfragen sowie der Gesamtausführungszeit des Skripts ist mit Sicherheit nicht sehr teuer. Sie müssen dies auch nicht für jeden Seitenaufruf erledigen. Bei einem anständigen Verkehrsaufkommen können Sie auch einfach ein zufälliges Sample profilieren, indem Sie in der Setup-Datei Ihrer Anwendung das Profiling aktivieren: 99; ?>
Schon das Profiling von 1 % Ihrer Seitenbesuche sollte Ihnen dabei helfen, die schlimmsten Probleme zu finden. Denken Sie daran, die Kosten für Logging, Profiling und Messungen mit in Ihre Betrachtungen aufzunehmen, wenn Sie Benchmarks ausführen, da diese Ihre Benchmark-Ergebnisse verfälschen können.
Profiling | 61
Ein PHP-Profiling-Beispiel Um Ihnen eine Vorstellung davon zu vermitteln, wie einfach und unauffällig das Profiling einer PHP-Webanwendung sein kann, wollen wir uns einige Codebeispiele anschauen. Das erste Beispiel zeigt, wie man die Anwendung anpasst, die Abfragen und weitere Profiling-Daten in einer MySQL-Tabelle aufzeichnet und die Ergebnisse analysiert. Um die Wirkung des Logging zu reduzieren, erfassen wir alle Logging-Informationen im Speicher und schreiben sie erst dann in eine einzelne Zeile, wenn die Ausführung der Seite beendet ist. Das ist besser, als wenn man jede Abfrage einzeln protokolliert, da das Logging jeder einzelnen Abfrage die Anzahl der Abfragen verdoppelt, die an den MySQLServer gesandt werden müssen. Das separate Protokollieren aller Profiling-Daten würde es noch schwerer machen, Engstellen zu analysieren, da Sie selten eine solche Granularität vorfinden, um Probleme in der Anwendung zu erkennen und zu beheben. Wir beginnen mit dem Code, den Sie benötigen, um die Profiling-Informationen zu erfassen. Hier ist ein vereinfachtes Beispiel einer grundlegenden PHP-5-Logging-Klasse namens class.Timer.php, in die bereits Funktionen wie getrusage( ) integriert sind, um den Ressourceneinsatz des Skripts festzustellen: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
62 |
aTIMES[$point]['start'] = microtime(TRUE); $this->aTIMES[$point]['start_utime'] = $dat["ru_utime.tv_sec"]*1e6+$dat["ru_utime.tv_usec"]; $this->aTIMES[$point]['start_stime'] = $dat["ru_stime.tv_sec"]*1e6+$dat["ru_stime.tv_usec"]; } function stopTime($point, $comment='') { $dat = getrusage( ); $this->aTIMES[$point]['end'] = microtime(TRUE); $this->aTIMES[$point]['end_utime'] = $dat["ru_utime.tv_sec"] * 1e6 + $dat["ru_utime.tv_usec"]; $this->aTIMES[$point]['end_stime'] = $dat["ru_stime.tv_sec"] * 1e6 + $dat["ru_stime.tv_usec"]; $this->aTIMES[$point]['comment'] .= $comment; $this->aTIMES[$point]['sum'] += $this->aTIMES[$point]['end'] - $this->aTIMES[$point]['start'];
Kapitel 2: Engpässe finden: Benchmarking und Profiling
33 $this->aTIMES[$point]['sum_utime'] += 34 ($this->aTIMES[$point]['end_utime'] 35 $this->aTIMES[$point]['start_utime']) / 1e6; 36 $this->aTIMES[$point]['sum_stime'] += 37 ($this->aTIMES[$point]['end_stime'] 38 $this->aTIMES[$point]['start_stime']) / 1e6; 39 } 40 41 function logdata( ) { 42 43 $query_logger = DBQueryLog::getInstance('DBQueryLog'); 44 $data['utime'] = $this->aTIMES['Page']['sum_utime']; 45 $data['wtime'] = $this->aTIMES['Page']['sum']; 46 $data['stime'] = $this->aTIMES['Page']['sum_stime']; 47 $data['mysql_time'] = $this->aTIMES['MySQL']['sum']; 48 $data['mysql_count_queries'] = $this->aTIMES['MySQL']['cnt']; 49 $data['mysql_queries'] = $this->aTIMES['MySQL']['comment']; 50 $data['sphinx_time'] = $this->aTIMES['Sphinx']['sum']; 51 52 $query_logger->logProfilingData($data); 53 54 } 55 56 // This helper function implements the Singleton pattern 57 function getInstance( ) { 58 static $instance; 59 60 if(!isset($instance)) { 61 $instance = new Timer( ); 62 } 63 64 return($instance); 65 } 66 } 67 ?>
Es ist ganz leicht, die Timer-Klasse in Ihrer Anwendung einzusetzen. Sie müssen potenziell teure (oder anderweitig interessante) Aufrufe einfach mit dem Timer umhüllen. Und so packen Sie z.B. einen Timer um jede MySQL-Abfrage. Die neue PHP-Schnittstelle mysqli erlaubt es Ihnen, die grundlegende Klasse mysqli zu erweitern und die Methode query neu zu deklarieren: 1 2 3 4 5 6 7 8 9 10 11
startTime('MySQL'); $res = parent::query($query, $resultmode); $timer->stopTime('MySQL', "Query: $query\n"); return $res; } } ?>
Profiling | 63
Diese Technik erfordert nur wenige Codeänderungen. Sie können einfach mysqli global auf mysqlx ändern, und Ihre Anwendung beginnt, alle Abfragen zu protokollieren. Mit diesem Ansatz haben Sie die Möglichkeit, den Zugriff auf jede externe Ressource zu messen, wie etwa Abfragen an die Volltextsuchmaschine Sphinx: $timer->startTime('Sphinx'); $this->sphinxres = $this->sphinx_client->Query ( $query, "index" ); $timer->stopTime('Sphinx', "Query: $query\n");
Jetzt wollen wir uns anschauen, wie wir die Daten aufzeichnen, die Sie sammeln. In diesem Beispiel wäre es klug, die Storage-Engine MyISAM oder Archive zu verwenden. Beide eignen sich gut zum Speichern von Logs. Wir benutzen INSERT DELAYED, wenn wir Zeilen zu den Logs hinzufügen, damit das INSERT auf dem Datenbankserver als Hintergrund-Thread ausgeführt wird. Dies bedeutet, dass die Abfrage sofort zurückkehrt und damit die Antwortzeit der Anwendung nicht merklich beeinflusst. (Selbst wenn wir nicht INSERT DELAYED benutzen, geschieht das Einfügen nebenläufig, solange wir es nicht ausdrücklich deaktivieren, so dass externe SELECT-Abfragen nicht das Logging blockieren.) Schließlich richten wir ein datumsbasiertes Partitionierungsschema ein, indem wir jeden Tag eine neue Log-Tabelle anlegen. Hier ist die CREATE TABLE-Anweisung für unsere Logging-Tabelle: CREATE TABLE logs.performance_log_template ( ip INT UNSIGNED NOT NULL, page VARCHAR(255) NOT NULL, utime FLOAT NOT NULL, wtime FLOAT NOT NULL, mysql_time FLOAT NOT NULL, sphinx_time FLOAT NOT NULL, mysql_count_queries INT UNSIGNED NOT NULL, mysql_queries TEXT NOT NULL, stime FLOAT NOT NULL, logged TIMESTAMP NOT NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP, user_agent VARCHAR(255) NOT NULL, referer VARCHAR(255) NOT NULL ) ENGINE=ARCHIVE;
Tatsächlich fügen wir niemals Daten in diese Tabelle ein; es handelt sich nur um ein Template für die CREATE TABLE LIKE-Anweisungen, die wir benutzen, um die Tabellen für die Daten der einzelnen Tage anzulegen. Mehr dazu erläutern wir in Kapitel 3. Im Moment sollten Sie nur wissen, dass es ganz gut ist, wenn man den kleinsten Datentyp benutzt, der die vorgesehenen Daten aufnehmen kann. Wir verwenden ein vorzeichenloses Integer, um die IP-Adresse zu speichern. Darüber hinaus verwenden wir eine 255 Zeichen lange Spalte für die Seite und den Referrer. Diese Werte können länger als 255 Zeichen sein, allerdings genügen für unsere Zwecke normalerweise die ersten 255.
64 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Das letzte Stück des Puzzles besteht darin, die Ergebnisse aufzuzeichnen, wenn die Ausführung der Seite beendet ist. Hier ist der dazu notwendige PHP-Code: 1 2 3 4 5 6 7 8 9
startTime('Page'); // ... other code ... // End of the page execution $timer->stopTime('Page'); $timer->logdata( ); ?>
Die Timer-Klasse verwendet die Helper-Klasse DBQueryLog, die dafür verantwortlich ist, dass in die Datenbank protokolliert und jeden Tag eine neue Log-Tabelle erzeugt wird. Hier ist der Code: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
mysqlx->query($query); // Handle "table not found" error - create new table for each new day if ((!$res) && ($this->mysqlx->errno == 1146)) { // 1146 is table not found $res = $this->mysqlx->query( "CREATE TABLE $table_name LIKE logs.performance_log_template"); $res = $this->mysqlx->query($query); } } } ?>
Sobald wir einige Daten aufgezeichnet haben, können wir die Logs analysieren. Das Schöne am Verwenden von MySQL für das Logging ist, dass Ihnen die Flexibilität von SQL für die Analyse zugute kommt; so können Sie einfach Abfragen schreiben, um beliebige Berichte aus den Logs zu erstellen. Um etwa Seiten zu ermitteln, deren Ausführung am ersten Tag des Februar 2007 länger als 10 Sekunden dauerte, schreiben Sie:
Profiling | 65
mysql> SELECT page, wtime, mysql_time -> FROM performance_log_070201 WHERE wtime > 10 LIMIT 7; +-------------------------------------------+---------+------------+ | page | wtime | mysql_time | +-------------------------------------------+---------+------------+ | /page1.php | 50.9295 | 0.000309 | | /page1.php | 32.0893 | 0.000305 | | /page1.php | 40.4209 | 0.000302 | | /page3.php | 11.5834 | 0.000306 | | /login.php | 28.5507 | 28.5257 | | /access.php | 13.0308 | 13.0064 | | /page4.php | 32.0687 | 0.000333 | +-------------------------------------------+---------+------------+
(Normalerweise würden wir in einer solchen Abfrage mehr Daten auswählen. Zur besseren Verdeutlichung haben wir das hier abgekürzt.) Wenn Sie die wtime (Wall-Clock-Zeit) und die Abfragezeit vergleichen, werden Sie feststellen, dass die Ausführungszeit der MySQL-Abfrage bei nur zwei der sieben Seiten für die langsame Antwortzeit verantwortlich war. Da wir die Abfragen bei den ProfilingDaten gespeichert haben, können wir sie uns zur näheren Untersuchung heraussuchen: mysql> SELECT mysql_queries -> FROM performance_log_070201 WHERE mysql_time > 10 LIMIT 1\G *************************** 1. row *************************** mysql_queries: Query: SELECT id, chunk_id FROM domain WHERE domain = 'domain.com' Time: 0.00022602081298828 Query: SELECT server.id sid, ip, user, password, domain_map.id as chunk_id FROM server JOIN domain_map ON (server.id = domain_map.master_id) WHERE domain_map.id = 24 Time: 0.00020599365234375 Query: SELECT id, chunk_id, base_url,title FROM site WHERE id = 13832 Time: 0.00017690658569336 Query: SELECT server.id sid, ip, user, password, site_map.id as chunk_id FROM server JOIN site_map ON (server.id = site_map.master_id) WHERE site_map.id = 64 Time: 0.0001990795135498 Query: SELECT from_site_id, url_from, count(*) cnt FROM link24.link_in24 FORCE INDEX (domain_message) WHERE domain_id=435377 AND message_day IN (...) GROUP BY from_site_id ORDER BY cnt desc LIMIT 10 Time: 6.3193740844727 Query: SELECT revert_domain, domain_id, count(*) cnt FROM art64.link_out64 WHERE from_ site_id=13832 AND message_day IN (...) GROUP BY domain_id ORDER BY cnt desc LIMIT 10 Time: 21.3649559021
Dabei werden zwei problematische Abfragen aufgedeckt, die mit Ausführungszeiten von 6,3 und 21,3 Sekunden einer Optimierung bedürfen. Alle Abfragen auf diese Weise zu protokollieren ist sehr teuer, weshalb wir entweder nur einen Bruchteil der Seiten aufzeichnen oder das Logging nur im Debug-Modus aktivieren. Wie können Sie feststellen, ob es eine Engstelle in dem Teil des Systems gibt, den Sie nicht profilieren? Am einfachsten ist es, wenn Sie sich die »verlorene Zeit« anschauen. Im Allgemeinen ist die Wall-Clock-Zeit (wtime) die Summe aus Benutzerzeit, Systemzeit, Zeit 66 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
für die SQL-Abfrage und jeder anderen Zeit, die Sie messen können, sowie der »verlorenen Zeit«, die Sie nicht messen können. Es gibt natürlich Überschneidungen, wie etwa die CPU-Zeit, die der PHP-Code benötigt, um die SQL-Abfragen zu verarbeiten, diese kann man aber üblicherweise vernachlässigen. Abbildung 2-2 ist eine hypothetische Darstellung für die Aufteilung der Wall-Clock-Zeit. 13%
Benutzerzeit
23%
Systemzeit Abfragen Netzwerk-Ein/Ausgaben
2%
24%
Verlorene Zeit
38%
Abbildung 2-2: Die verlorene Zeit ist die Differenz zwischen der Wall-Clock-Zeit und der Zeit, für die Sie einen Nachweis haben.
Idealerweise sollte die »verlorene Zeit« so gering wie möglich ausfallen. Wenn Sie alles, was Sie gemessen haben, von wtime abziehen, und immer noch viel übrig bleibt, dann erhöht irgendetwas, das Sie nicht messen, die Ausführungszeit Ihres Skripts. Das könnte die Zeit sein, die zum Generieren der Seite erforderlich ist, oder eine irgendwie geartete Wartezeit.5 Es gibt zwei Arten von Wartezeiten: das Warten in der Warteschlange auf CPU-Zeit und das Warten auf Ressourcen. Ein Prozess wartet in der Warteschlange, wenn er bereit zur Ausführung ist, aber alle CPUs ausgelastet sind. Normalerweise ist es nicht möglich festzustellen, wie viel Zeit ein Prozess wartend in der CPU-Warteschlange verbringt, aber das ist im Allgemeinen nicht das Problem. Es ist wahrscheinlicher, das Sie einen externen Ressourcenaufruf ausführen und ihn nicht profilieren. Wenn Ihr Profiling einigermaßen vollständig ist, sollten Sie leicht in der Lage sein, Engpässe zu finden. Es ist eigentlich ganz einfach: Besteht die Ausführungszeit Ihres Skripts zum größten Teil aus CPU-Zeit, müssen Sie wahrscheinlich Ihren PHP-Code optimieren. Manchmal werden Messungen allerdings durch andere verdeckt. So haben Sie z.B. vielleicht eine hohe CPU-Auslastung, weil es einen Bug gibt, der das Cache-System ineffizient macht und Ihre Anwendung zwingt, zu viele SQL-Abfragen auszuführen. Wie dieses Beispiel demonstriert, bildet das Profiling auf Anwendungsebene die flexibelste und nützlichste Technik. Falls es sich ermöglichen lässt, sollten Sie das Profiling in jede Anwendung einbinden, die Sie auf potenzielle Leistungsengpässe hin untersuchen müssen. 5 Angenommen, der Webserver puffert das Ergebnis, so dass die Ausführung des Skripts endet und Sie nicht die Zeit messen, die es in Anspruch nimmt, das Ergebnis an den Client zu senden.
Profiling | 67
Zuletzt sollten wir noch darauf hinweisen, dass wir hier nur grundlegende AnwendungsProfiling-Techniken gezeigt haben. Wir wollen Ihnen in diesem Abschnitt einfach zeigen, wie Sie feststellen, ob MySQL das Problem ist. Vielleicht wollen Sie ja auch den Code der Anwendung selbst profilieren. Falls Sie z.B. beschließen, Ihren PHP-Code zu optimieren, weil er zu viel CPU-Zeit beansprucht, können Sie die CPU-Benutzung mit Werkzeugen wie etwa xdebug, Valgrind und cachegrind profilieren. In manche Sprachen ist bereits eine Unterstützung für das Profiling integriert. So lässt sich z.B. Ruby-Code mit der Kommandozeilenoption -r profilieren. Bei Perl gehen Sie folgendermaßen vor: $ perl -d:DProf <Skriptdatei> $ dprofpp tmon.out
Eine Websuche nach »Profiling <Sprache>« ist ein guter Einstieg.
MySQL-Profiling Wir befassen uns nun ausführlicher mit MySQL-Profiling, weil dies weniger stark von Ihrer speziellen Anwendung abhängt. Manchmal sind sowohl Anwendungs-Profiling als auch Server-Profiling erforderlich. Obwohl das Anwendungs-Profiling Ihnen ein vollständigeres Bild der Leistung des gesamten Systems liefern kann, bekommen Sie beim Profiling von MySQL möglicherweise Informationen, die Ihnen verborgen bleiben, wenn Sie sich die Anwendung als Ganzes anschauen. So erfahren Sie etwa beim Profiling Ihres PHP-Codes nicht, wie viele Zeilen MySQL zum Ausführen der Abfragen untersucht hat. Wie beim Profiling von Anwendungen besteht das Ziel darin, festzustellen, wo MySQL einen Großteil seiner Zeit verbringt. Wir werden uns nicht mit dem Profiling des Quellcodes von MySQL befassen, auch wenn das für eigene MySQL-Installationen manchmal sinnvoll sein kann. Dies könnte das Thema eines weiteren Buches sein. Stattdessen zeigen wir Ihnen einige Techniken, mit deren Hilfe Sie Informationen über die verschiedenen Arbeiten bekommen, die MySQL erledigt, um Abfragen auszuführen, und mit denen Sie diese Informationen analysieren können. Sie können auf der Granularitätsstufe arbeiten, die Ihnen am besten passt: Profilieren Sie den Server als Ganzes, oder untersuchen Sie einzelne Abfragen oder Folgen von Abfragen. Folgende Informationen können Sie unter anderem sammeln: • auf welche Daten MySQL am meisten zugreift • welche Arten von Abfragen MySQL am meisten ausführt • in welchen Zuständen die MySQL-Threads die meiste Zeit verbringen • welche Subsysteme MySQL am häufigsten benutzt, um eine Abfrage auszuführen • auf welche Arten von Daten MySQL während einer Abfrage zugreift • wie viele verschiedene Aktivitäten, wie etwa Indexscans, MySQL durchführt Wir beginnen mit der am breitesten angelegten Stufe, dem Profiling des gesamten Servers, und arbeiten uns dann zu den detaillierteren Bereichen vor. 68 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Logging von Abfragen MySQL besitzt zwei Arten von Abfrage-Logs: das allgemeine Log (General-Log) und das langsame Log (Slow-Log). Beide protokollieren Abfragen, allerdings an entgegengesetzten Enden der Abfrageverarbeitung. Das allgemeine Log zeichnet alle Abfragen auf, die der Server empfängt, so dass er auch Abfragen enthält, die möglicherweise aufgrund von Fehlern gar nicht ausgeführt wurden. Das allgemeine Log zeichnet alle Abfragen auf sowie weitere Ereignisse, wie das Starten und Beenden von Verbindungen auf. Sie können es mit einer einzigen Konfigurationsdirektive aktivieren: log =
Aufgrund seiner Gestaltung enthält das allgemeine Log keine Ausführungszeiten oder andere Informationen, die erst verfügbar sind, wenn die Abfrage abgeschlossen ist. Im Gegensatz dazu enthält das Slow-Log nur Abfragen, die ausgeführt wurden. Es zeichnet speziell Abfragen auf, die für die Ausführung länger als eine festgelegte Zeit benötigt haben. Beide Logs können für das Profiling nützlich sein, allerdings eignet sich vor allem das Slow-Log zum Erkennen problematischer Abfragen. Wir empfehlen Ihnen normalerweise, es zu aktivieren. Das folgende Konfigurationsbeispiel aktiviert das Log, erfasst alle Abfragen, die länger als zwei Sekunden für die Ausführung benötigen, und protokolliert Abfragen, die keine Indizes verwenden. Es zeichnet außerdem langsame administrative Anweisungen auf, wie etwa OPTIMIZE TABLE: log-slow-queries = long_query_time = 2 log-queries-not-using-indexes log-slow-admin-statements
Sie sollten dieses Beispiel anpassen und in Ihre my.cnf-Serverkonfigurationsdatei setzen. Mehr Informationen über die Serverkonfiguration finden Sie in Kapitel 6. Der vorgegebene Wert für long_query_time beträgt 10 Sekunden. Das ist für die meisten Gegebenheiten zu lang, weshalb wir meist zwei Sekunden empfehlen. Es gibt allerdings auch Anwendungsfälle, für die schon eine Sekunde zu lang ist. Im nächsten Abschnitt zeigen wir Ihnen, wie Sie ein feiner aufgelöstes Logging erhalten. In MySQL 5.1 bieten die globalen Systemvariablen slow_query_log und slow_query_ log_file eine Kontrolle zur Laufzeit über das Slow-Query-Log. In MySQL 5.0 dagegen können Sie das Slow-Log nicht ein- oder ausschalten, ohne den MySQL-Server neu zu starten. Die übliche Lösung für MySQL 5.0 besteht in der Variablen long_query_time, die Sie dynamisch ändern können. Der folgende Befehl deaktiviert das Slow-Query-Log zwar nicht, hat aber praktisch die gleiche Wirkung. (Wenn eine Ihrer Abfragen länger als 10.000 Sekunden für die Ausführung braucht, sollten Sie sowieso optimieren!) mysql> SET GLOBAL long_query_time = 10000;
Eine verwandte Konfigurationsvariable, log_queries_not_using_indexes, veranlasst den Server dazu, alle Abfragen in das Slow-Log zu protokollieren, die keine Indizes verwenden, und zwar ungeachtet dessen, wie schnell sie ausgeführt werden. Obwohl das Akti-
Profiling | 69
vieren des Slow-Logs normalerweise nur einen geringen Logging-Overhead verursacht, der sich relativ zu der Zeit verhält, die eine »langsame« Abfrage zur Ausführung braucht, können Abfragen ohne Indizes häufig auftreten und sehr schnell sein (wie etwa Scans sehr kleiner Tabellen). Das Protokollieren dieser Abfragen kann daher den Server verlangsamen und darüber hinaus viel Plattenplatz für das Log belegen. Leider können Sie in MySQL 5.0 das Logging dieser Abfragen nicht mit einer dynamisch einstellbaren Variablen aktivieren oder deaktivieren. Sie müssen die Konfigurationsdatei bearbeiten und dann MySQL neu starten. Eine Möglichkeit, den Aufwand zu reduzieren, ohne einen Neustart zu benötigen, besteht darin, die Log-Datei zu einem symbolischen Link auf /dev/null zu machen, wenn Sie sie deaktivieren wollen (dieser Trick funktioniert auch bei jeder anderen Log-Datei). Sie müssen lediglich FLUSH LOGS ausführen, nachdem Sie die Änderung vorgenommen haben, um sicherzustellen, dass MySQL seinen aktuellen Log-Datei-Deskriptor schließt und den in /dev/null neu öffnet. Im Gegensatz zu MySQL 5.0 erlaubt es Ihnen MySQL 5.1, das Logging zur Laufzeit zu ändern. Sie können außerdem das Log in Tabellen speichern, die Sie mit SQL abfragen können. Das ist eine tolle Verbesserung.
Feinere Kontrolle über das Logging Das Slow-Query-Log in MySQL 5.0 und früheren Versionen unterliegt einigen Einschränkungen, die es für manche Zwecke ungeeignet machen. Ein Problem besteht darin, dass seine Granularität nur in Sekunden besteht und der Minimalwert für long_query_ time in MySQL 5.0 eine Sekunde ist. Für die meisten interaktiven Anwendungen ist das viel zu lang. Falls Sie eine leistungsstarke Webanwendung entwickeln, dann soll wahrscheinlich die ganze Seite in viel weniger als einer Sekunde generiert werden. Außerdem führt die Seite vermutlich viele Abfragen aus, während sie generiert wird. In diesem Zusammenhang würde eine Abfrage, die 150 Millisekunden für die Ausführung braucht, sicherlich als sehr langsam angesehen. Ein weiteres Problem besteht darin, dass Sie nicht alle Abfragen, die der Server ausführt, in das Slow-Log schreiben können (dies betrifft vor allem die Abfragen des SlaveThreads). Das allgemeine Log protokolliert alle Abfragen, allerdings bereits, bevor sie überprüft werden, so dass es keine Informationen über die Ausführungszeit, die LockZeit und die Anzahl der untersuchten Zeilen enthält. Diese Informationen gibt es nur im Slow-Log. Falls Sie schließlich die Option log_queries_not_using_indexes aktivieren, könnte Ihr Slow-Log mit Einträgen für schnelle, effiziente Abfragen überflutet werden, die vollständige Tabellenscans durchführen. Wenn Sie z.B. eine Dropdown-Liste mit Zuständen aus SELECT * FROM STATES generieren, dann wird diese Abfrage protokolliert, da sie ein vollständiger Tabellenscan ist. Beim Profiling zum Zwecke der Leistungsoptimierung suchen Sie nach Abfragen, die die meiste Arbeit auf dem MySQL-Server verursachen. Das bedeutet nicht immer langsame Abfragen, weshalb die Idee des Protokollierens »langsamer« Abfragen nicht unbedingt 70 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
sinnvoll ist. So würde etwa eine 10-Millisekunden-Abfrage, die 1.000-mal pro Sekunde ausgeführt wird, den Server stärker belasten als eine 10-Sekunden-Abfrage, die einmal pro Sekunde läuft. Um ein solches Problem zu erkennen, müssen Sie jede Abfrage protokollieren und die Ergebnisse analysieren. Im Allgemeinen bietet es sich an, sowohl die langsamen Abfragen anzuschauen (auch wenn sie nicht oft ausgeführt werden) als auch die Abfragen, die insgesamt dem Server die meiste Arbeit machen. Auf diese Weise können Sie unterschiedliche Arten von Problemen aufdecken, wie z.B. Abfragen, die schlechte Benutzererfahrungen verursachen. Wir haben auf der Grundlage der Arbeit von Georg Richter einen Patch für den MySQLServer entwickelt, der es Ihnen erlaubt, langsame Abfragezeiten in Mikrosekunden anstatt in Sekunden anzugeben. Er ermöglicht Ihnen außerdem, alle Abfragen in das Slow-Log zu protokollieren, indem Sie long_query_time=0 setzen. Der Patch steht unter http://www.mysqlperformanceblog.com/mysql-patches/ zur Verfügung. Allerdings müssen Sie MySQL möglicherweise selbst kompilieren, wenn Sie ihn benutzen wollen, da er vor MySQL Version 5.1 nicht in der offiziellen MySQL-Distribution enthalten ist. Momentan ändert die Version des Patches, die in MySQL 5.1 enthalten ist, nur die Zeitauflösung. Eine neue Version, die es noch nicht in irgendeiner offiziellen MySQL-Distribution gibt, bringt weitere nützliche Funktionen mit. Der Patch enthält die VerbindungsID der Abfrage sowie Informationen über den Abfrage-Cache, den Join-Typ, temporäre Tabellen und die Sortierung. Außerdem liefert er InnoDB-Statistiken, wie etwa Informationen über das Ein-/Ausgabeverhalten und die Lock-Wartezeiten. Der neue Patch erlaubt es Ihnen, Abfragen zu protokollieren, die vom SQL-Slave-Thread ausgeführt werden, was sehr wichtig ist, wenn es Probleme mit Replikations-Slaves gibt, die hinterherhinken. (In »Übermäßiger Rückstand bei der Replikation« auf Seite 434 finden Sie weitere Informationen darüber, wie Sie den Slaves helfen können, Schritt zu halten.) Außerdem können Sie sich beim Logging auf einige Sessions beschränken. Für die Zwecke des Profilings reicht das normalerweise. Wir glauben, dass dies ein gutes Vorgehen ist. Dieser Patch ist relativ neu. Sie müssen deshalb mit einer gewissen Vorsicht zu Werke gehen, wenn Sie ihn selbst anwenden. Unserer Meinung nach ist er ziemlich sicher, wurde aber natürlich noch nicht so ausgiebig im Betrieb getestet wie der Rest des MySQL-Servers. Falls Sie sich Sorgen wegen der Stabilität des gepatchten Servers machen, müssen Sie die gepatchte Version nicht die ganze Zeit benutzen. Sie können sie einfach für ein paar Stunden starten, um einige Abfragen zu protokollieren, und dann zur ungepatchten Version zurückkehren. Beim Profiling sollte man alle Abfragen mit long_query_time=0 protokollieren. Wenn ein Großteil Ihrer Last von sehr einfachen Abfragen kommt, werden Sie dies sicher erfahren wollen. Das Logging all dieser Abfragen beeinflusst in gewissem Maße die Leistung und erfordert eine Menge Plattenplatz – ein weiterer Grund, weshalb Sie nicht jede einzelne Abfrage protokollieren sollten. Glücklicherweise können Sie long_query_time ändern,
Profiling | 71
ohne den Server neu zu starten, so dass Sie sich leicht für einen bestimmten Zeitraum alle Abfragen beschaffen können; anschließend protokollieren Sie wieder nur sehr langsame Abfragen.
Wie man das Slow-Query-Log liest Hier ist ein Beispiel aus einem Slow-Query-Log: 1 2 3 4
# Time: 030303 0:51:27 # User@Host: root[root] @ localhost [] # Query_time: 25 Lock_time: 0 Rows_sent: 3949 SELECT ...
Rows_examined: 378036
Zeile 1 zeigt, wann die Abfrage protokolliert wurde, und Zeile 2 zeigt, wer sie ausgeführt hat. In Zeile 3 steht, wie viele Sekunden es gedauert hat, die Abfrage auszuführen, wie lange sie auf Tabellen-Locks auf der MySQL-Serverebene (nicht auf der Storage-EngineEbene) gewartet hat, wie viele Zeilen die Abfrage zurückgeliefert hat und wie viele Zeilen untersucht wurden. Diese Zeilen sind auskommentiert, sie werden also nicht ausgeführt, wenn Sie das Log einem MySQL-Client übergeben. Die letzte Zeile enthält die Abfrage. Hier ist ein Ausschnitt von einem MySQL 5.1-Server: 1 2 3 4
# Time: 070518 9:47:00 # User@Host: root[root] @ localhost [] # Query_time: 0.000652 Lock_time: 0.000109 SELECT ...
Rows_sent: 1
Rows_examined: 1
Die Informationen sind größtenteils gleich, allerdings werden die Zeiten in Zeile 3 genauer angegeben. Eine neuere Version des Patchs liefert sogar noch mehr Informationen: 1 2 3 4 5 6 7 8 9 10
# Time: 071031 20:03:16 # User@Host: root[root] @ localhost [] # Thread_id: 4 # Query_time: 0.503016 Lock_time: 0.000048 Rows_sent: 56 Rows_examined: 1113 # QC_Hit: No Full_scan: No Full_join: No Tmp_table: Yes Disk_tmp_table: No # Filesort: Yes Disk_filesort: No Merge_passes: 0 # InnoDB_IO_r_ops: 19 InnoDB_IO_r_bytes: 311296 InnoDB_IO_r_wait: 0.382176 # InnoDB_rec_lock_wait: 0.000000 InnoDB_queue_wait: 0.067538 # InnoDB_pages_distinct: 20 SELECT ...
Zeile 5 zeigt, ob die Abfrage aus dem Abfrage-Cache bedient wurde, ob ein vollständiger Tabellenscan erfolgte, ob ein Join ohne Indizes durchgeführt wurde, ob eine temporäre Tabelle zum Einsatz kam und, falls dies der Fall war, ob die temporäre Tabelle auf der Festplatte erzeugt wurde. Zeile 6 gibt an, ob die Abfrage ein Filesort durchgeführt hat und ob, falls dies geschehen ist, dies auf der Festplatte passierte, und wie viele SortMerge-Durchläufe sie ausgeführt hat. Die Zeilen 7, 8 und 9 tauchen auf, falls die Abfrage InnoDB verwendet hat. Zeile 7 zeigt, wie viele Seitenleseoperationen InnoDB während der Abfrage eingetaktet hat, und gibt die dazugehörenden Werte in Byte an. Der letzte Wert in Zeile 7 zeigt, wie lange InnoDB
72 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
zum Lesen der Daten von der Festplatte gebraucht hat. Auf Zeile 8 sehen Sie, wie lange die Abfrage auf Row-Locks gewartet hat und wie lange sie warten musste, um in den InnoDB-Kernel zu gelangen.6 Zeile 9 zeigt ungefähr, auf wie viele einzelne InnoDB-Seiten die Abfrage zugegriffen hat. Je größer dieser Wert wird, umso ungenauer wird er wahrscheinlich. Eine Anwendung für diese Information besteht darin, die Arbeitsmenge der Abfrage in Seiten abzuschätzen, die angibt, wie der InnoDB-Pufferpool die Daten im Cache speichert. Sie kann Ihnen auch zeigen, wie hilfreich Cluster-Indizes wirklich sind. Wenn die Zeilen der Abfrage gut in Cluster aufgeteilt sind, passen sie in weniger Seiten. Mehr zu diesem Thema finden Sie in »Cluster-Indizes« auf Seite 118. Die Benutzung des Slow-Query-Logs, um Probleme mit langsamen Abfragen zu beheben ist nicht immer ganz einfach. Das Log enthält zwar eine Menge an nützlichen Informationen, eine wichtige Information allerdings fehlt: ein Hinweis darauf, wieso eine Abfrage langsam war. Manchmal ist es offensichtlich. Wenn das Log angibt, dass 12.000.000 Zeilen untersucht wurden und 1.200.000 an den Client geschickt wurden, dann wissen Sie, wieso die Ausführung so lange dauerte – es war einfach eine riesige Abfrage! Es ist allerdings nur selten so deutlich. Passen Sie auf, dass Sie nicht zu viel in das Slow-Query-Log hineinlesen. Wenn Sie die gleiche Abfrage oft in dem Log sehen, kann das durchaus bedeuten, dass sie langsam ist und optimiert werden muss. Aber nur, weil eine Abfrage im Log auftaucht, muss sie nicht unbedingt schlecht oder gar langsam sein. Vielleicht finden Sie eine langsame Abfrage, führen sie selbst aus und stellen fest, dass sie im Bruchteil einer Sekunde erledigt ist. Das Auftauchen im Log bedeutet einfach, dass die Abfrage damals lange brauchte, das muss jetzt oder in Zukunft nicht so sein. Es gibt viele Gründe, wieso eine Abfrage manchmal langsam und manchmal schnell ist: • Eine Tabelle könnte gesperrt gewesen sein, weshalb die Abfrage warten musste. Der Lock_time-Wert gibt an, wie lange die Abfrage darauf warten musste, dass Sperren freigegeben wurden. • Die Daten oder Indizes stehen noch nicht im Cache zur Verfügung. Das kommt häufig vor, wenn MySQL erst gestartet wurde oder nicht gut eingestellt ist. • Es läuft ein nächtlicher Backup-Prozess, der alle Festplattenzugriffe verlangsamt. • Der Server führt gleichzeitig noch weitere Abfragen aus, so dass diese Abfrage gebremst wird. Sie sollten also das Slow-Query-Log nur als Teil der Aufzeichnung dessen betrachten, was passiert ist. Verwenden Sie es etwa, um eine Liste der möglichen Verdächtigen herzustellen, untersuchen Sie die einzelnen Kandidaten dann aber genauer.
6 Siehe »InnoDB bei Nebenläufigkeit anpassen« auf Seite 321 für weitere Informationen über den InnoDB-Kernel.
Profiling | 73
Die Patches für das Slow-Query-Log sollen Ihnen dabei helfen zu verstehen, weshalb eine Abfrage langsam ist. Speziell im Fall von InnoDB können die InnoDB-Statistiken Sie unterstützen: Sie können sehen, ob die Abfrage auf eine Ein-/Ausgabe von der Platte gewartet hat, ob sie viel Zeit mit Warten in der InnoDB-Warteschlange verbringen musste usw.
Log-Analysewerkzeuge Nachdem Sie einige Abfragen protokolliert haben, müssen Sie die Ergebnisse analysieren. Die allgemeine Strategie sieht so aus: Suchen Sie die Abfragen, die den Server am meisten beeinflussen, überprüfen Sie deren Ausführungspläne mit EXPLAIN, und passen Sie sie gegebenenfalls an. Wiederholen Sie die Analyse nach dem Anpassen, da Ihre Änderungen andere Abfragen beeinflussen können. Oft sind z.B. Indizes für SELECT-Abfragen hilfreich, verlangsamen aber INSERT- und UPDATE-Abfragen. Sie sollten im Allgemeinen in den Logs auf die folgenden drei Dinge achten: Lange Abfragen Routinemäßig ablaufende Batch-Jobs generieren lange Abfragen. Ihre normalen Abfragen dagegen sollten nicht sehr lange dauern. Einflussreiche Abfragen Suchen Sie die Abfragen, die den Großteil der Ausführungszeit des Servers ausmachen. Denken Sie daran, dass kurze Abfragen, die oft ausgeführt werden, ebenfalls viel Zeit in Anspruch nehmen können. Neue Abfragen Suchen Sie nach Abfragen, die gestern noch nicht unter den Top 100 waren, es heute aber sind. Dabei kann es sich um neue Abfragen handeln, aber auch um solche, die eigentlich schnell ausgeführt werden, jetzt aber von einer unterschiedlichen Indizierung oder einer anderen Änderung negativ beeinflusst werden. Wenn Ihr Slow-Query-Log relativ klein ist, können Sie die Analyse leicht von Hand erledigen, falls Sie jedoch alle Abfragen protokollieren (wie wir es empfehlen), brauchen Sie ein Werkzeug. Hier ist eine Auswahl: mysqldumpslow MySQL liefert mysqldumpslow mit dem MySQL-Server. Es handelt sich hierbei um ein Perl-Skript, das das Slow-Query-Log zusammenfassen kann und Ihnen zeigt, wie oft die einzelnen Abfragen jeweils im Log auftauchen. Auf diese Weise verschwenden Sie keine Zeit damit, eine langsame 30-Sekunden-Abfrage zu optimieren, die nur einmal am Tag ausgeführt wird, wenn es viele andere kürzere langsame Abfragen gibt, die Tausende Male am Tag laufen. Der Vorteil von mysqldumpslow besteht darin, dass es bereits installiert ist. Allerdings ist es etwas weniger flexibel als einige der anderen Werkzeuge. Außerdem ist es schlecht dokumentiert und versteht Logs von Servern nicht, die mit dem oben beschriebenen Mikrosekunden-Patch ausgestattet wurden.
74 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
mysql_slow_log_filter Dieses Werkzeug, das unter http://www.mysqlperformanceblog.com/files/utils/ mysql_slow_log_filter zur Verfügung steht, versteht das Mikrosekunden-Log-Format. Sie können es einsetzen, um Abfragen zu extrahieren, die länger sind als ein vorgegebener Schwellenwert, oder die mehr als eine bestimmte Anzahl von Zeilen untersuchen. Es eignet sich großartig zum »Nachziehen« Ihrer Log-Datei, wenn Sie den Mikrosekunden-Patch verwenden, der möglicherweise dafür sorgt, dass Ihr Log zu schnell anwächst, so dass Sie ihm ohne eine Filterung gar nicht mehr folgen können. Sie können das Programm eine Weile mit hohen Schwellenwerten ausführen, dann eine Optimierung vornehmen, bis die schlimmsten Missetäter beseitigt sind, anschließend die Parameter ändern, um weitere Abfragen zu erfassen, und das Einstellen fortsetzen. Hier ist ein Befehl, der Abfragen zeigt, die entweder länger als eine halbe Sekunde laufen oder mehr als 1.000 Zeilen untersuchen: $ tail -f mysql-slow.log | mysql_slow_log_filter -T 0.5 -R 1000
mysql_slow_log_parser Mit diesem Werkzeug, das Sie unter http://www.mysqlperformanceblog.com/files/ utils/mysql_slow_log_parser finden, können Sie das Mikrosekunden-Slow-Log zusammenfassen. Darüber hinaus zeigt es Minimal- und Maximalwerte für die Ausführungszeit sowie die Anzahl der analysierten Zeilen an, gibt die »kanonisierte« Abfrage aus und liefert einen tatsächlichen Auszug, den Sie mit EXPLAIN untersuchen können. Hier ist ein Auszug aus seiner Ausgabe: ### 3579 Queries ### Total time: 3.348823, Average time: 0.000935686784017883 ### Taking 0.000269 to 0.130820 seconds to complete ### Rows analyzed 1 - 1 SELECT id FROM forum WHERE id=XXX; SELECT id FROM forum WHERE id=12345;
mysqlsla Der MySQL Statement Log Analyzer, verfügbar unter http://hackmysql.com/ mysqlsla, kann nicht nur das Slow-Log, sondern auch das allgemeine Log sowie »raw« Logs analysieren, die begrenzte SQL-Anweisungen enthalten. Genau wie mysql_ slow_log_parser kann es kanonisieren und zusammenfassen, außerdem kann es Abfragen mit EXPLAIN untersuchen (es schreibt viele Nicht-SELECT-Anweisungen für EXPLAIN um) und ausgefeilte Berichte erzeugen. Mit den Statistiken für das Slow-Log lässt sich vorhersagen, um wie viel Sie den Ressourcenverbrauch des Servers reduzieren können. Nehmen Sie an, Sie erfassen eine Stunde lang (3.600 Sekunden) Abfragen und stellen fest, dass die gesamte kombinierte Ausführungszeit für alle Abfragen im Log 10.000 Sekunden beträgt. (Die Gesamtzeit ist größer als die tatsächlich verstrichene, d.h. die Wall-Clock-Zeit, weil die Abfragen parallel ausgeführt werden.) Wenn die Log-Analyse Ihnen zeigt, dass die schlechteste Abfrage für 3.000 Sekunden der Ausführungszeit verantwortlich ist, dann wissen Sie, dass diese Abfrage 30 % der Last erzeugt. Jetzt wissen Sie auch, um wie viel Sie den Ressourcenverbrauch des Servers senken können, indem Sie diese Abfrage optimieren. Profiling | 75
Profiling eines MySQL-Servers Eine der besten Methoden, um einen Server zu profilieren, d.h., um festzustellen, was er die meiste Zeit tut, ist mit SHOW STATUS. SHOW STATUS liefert viele Statusinformationen zurück. Wir erwähnen hier nur einige der Variablen in seiner Ausgabe. SHOW STATUS zeigt einige seltsame Verhaltensweisen, die in MySQL 5.0 und neueren Versionen schlechte Ergebnisse liefern können. In Kapitel 13 finden Sie weitere Details über das Verhalten von SHOW STATUS und seine Pferdefüße.
Um festzustellen, wie der Server in (ungefährer) Echtzeit arbeitet, erfassen Sie regelmäßig SHOW STATUS und vergleichen das Ergebnis mit der vorhergehenden Probe. Verwenden Sie dazu folgenden Befehl: mysqladmin extended -r -i 10
Einige der Variablen sind keine streng ansteigenden Zähler, weshalb Ihnen auch seltsame Ausgaben unterkommen können wie eine negative Zahl für Threads_running. Darüber müssen Sie sich keine Sorgen machen. Das bedeutet lediglich, dass der Zähler seit der letzten Erfassung verkleinert wurde. Die Ausgabe ist sehr ausführlich, lassen Sie die Ergebnisse deshalb am besten durch grep laufen, um Variablen herauszufiltern, die Sie nicht beobachten wollen. Alternativ können Sie innotop oder ein anderes der in Kapitel 14 erwähnten Werkzeuge einsetzen, um die Ergebnisse zu untersuchen. Hier sind einige der Variablen, die Sie sinnvollerweise genauer unter die Lupe nehmen sollten: Bytes_received und Bytes_sent
Der Verkehr zum und vom Server Com_*
Die Befehle, die der Server ausführt Created_*
Temporäre Tabellen und Dateien, die während der Ausführung der Abfrage erzeugt wurden Handler_*
Operationen der Storage-Engine Select_*
Verschiedene Arten von Join-Ausführungsplänen Sort_*
Verschiedene Arten von Sortierinformationen Mit diesem Ansatz können Sie interne Operationen von MySQL überwachen, wie etwa die Anzahl der Schlüsselzugriffe, Schlüssellesevorgänge von der Festplatte für MyISAM, die Rate des Datenzugriffs, Datenlesevorgänge von der Festplatte für InnoDB usw. Es hilft Ihnen festzustellen, wo sich in Ihrem System die echten oder potenziellen Engstellen
76 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
befinden, ohne dass Sie eine einzige Abfrage anschauen müssen. Es gibt auch Werkzeuge zur Analyse von SHOW STATUS, z.B. mysqlreport, die Ihnen einen Eindruck vom Gesamtzustand des Servers vermitteln. Wir werden die Bedeutung der Statusvariablen hier nicht allzu detailliert betrachten, erläutern sie aber, wenn wir sie in Beispielen einsetzen. Machen Sie sich also keine Sorgen, wenn Sie nicht wissen, was sie alle bedeuten. Eine andere gute Methode, um einen MySQL-Server zu profilieren, ist mit SHOW PROCESSLIST. Damit sehen Sie nicht nur, welche Arten von Abfragen ausgeführt werden, sondern auch, welchen Zustand Ihre Verbindungen aufweisen. Manche Dinge, wie z.B. eine große Anzahl von Verbindungen im Zustand Locked, deuten ganz offensichtlich auf Engpässe hin. Wie bei SHOW STATUS ist die Ausgabe von SHOW PROCESSLIST so umfangreich, dass es normalerweise bequemer ist, ein Werkzeug wie innotop einzusetzen, als sie manuell zu untersuchen.
Profiling von Abfragen mit SHOW STATUS Die Kombination aus FLUSH STATUS und SHOW SESSION STATUS eignet sich sehr gut, um festzustellen, was passiert, während MySQL eine Abfrage oder eine ganze Reihe von Abfragen ausführt. Damit können Sie die Abfragen optimieren. Schauen wir uns an einem Beispiel an, wie Sie die Aktionen einer Abfrage interpretieren. Führen Sie zuerst FLUSH STATUS aus, um die Statusvariablen der Sitzung auf null zurückzusetzen und sehen zu können, wie viel Arbeit MySQL erledigen muss, um die Abfrage durchzuführen: mysql> FLUSH STATUS;
Nun starten Sie die Abfrage. Wir setzen SQL_NO_CACHE hinzu, damit MySQL die Abfrage nicht einfach aus dem Cache beantwortet: mysql> SELECT SQL_NO_CACHE film_actor.actor_id, COUNT(*) -> FROM sakila.film_actor -> INNER JOIN sakila.actor USING(actor_id) -> GROUP BY film_actor.actor_id -> ORDER BY COUNT(*) DESC; ... 200 rows in set (0.18 sec)
Die Abfrage lieferte 200 Zeilen zurück, aber was hat sie wirklich getan? SHOW STATUS kann Ihnen einen Einblick liefern. Schauen wir uns zuerst an, welche Art von Abfrageplan der Server gewählt hat: mysql> SHOW SESSION STATUS LIKE 'Select%'; +------------------------+-------+ | Variable_name | Value | +------------------------+-------+ | Select_full_join | 0 | | Select_full_range_join | 0 | | Select_range | 0 |
Profiling | 77
| Select_range_check | 0 | | Select_scan | 2 | +------------------------+-------+
Es sieht so aus, als hätte MySQL einen vollständigen Tabellenscan durchgeführt. (Es sieht sogar so aus, als wären es zwei gewesen, aber das ist nur ein Überbleibsel von SHOW STATUS; wir kommen später darauf zurück.) Hätte sich die Abfrage auf mehr als eine Tabelle bezogen, dann wären möglicherweise mehrere Variablen größer als null gewesen. Falls MySQL z.B. einen Bereichsscan durchgeführt hätte, um passende Zeilen in der nachfolgenden Tabelle zu finden, dann hätte Select_full_range_join ebenfalls einen Wert erhalten. Wir können noch mehr Erkenntnisse gewinnen, wenn wir uns die systemnahen Storage-Engine-Operationen anschauen, die die Abfrage durchgeführt hat: mysql> SHOW SESSION STATUS LIKE 'Handler%'; +----------------------------+-------+ | Variable_name | Value | +----------------------------+-------+ | Handler_commit | 0 | | Handler_delete | 0 | | Handler_discover | 0 | | Handler_prepare | 0 | | Handler_read_first | 1 | | Handler_read_key | 5665 | | Handler_read_next | 5662 | | Handler_read_prev | 0 | | Handler_read_rnd | 200 | | Handler_read_rnd_next | 207 | | Handler_rollback | 0 | | Handler_savepoint | 0 | | Handler_savepoint_rollback | 0 | | Handler_update | 5262 | | Handler_write | 219 | +----------------------------+-------+
Die hohen Werte der »read«-Operationen deuten darauf hin, dass MySQL mehr als eine Tabelle scannen musste, um diese Abfrage zu beantworten. Würde MySQL nur eine Tabelle mit einem vollständigen Tabellenscan lesen, dann würden wir hohe Werte für Handler_read_rnd_next sehen, und Handler_read_rnd wäre null. In diesem Fall weisen die Werte, die nicht null sind, darauf hin, dass MySQL eine temporäre Tabelle benutzt haben muss, um die verschiedenen GROUP BY- und ORDER BY-Klauseln zu bedienen. Aus diesem Grund sind die Werte für Handler_write und Handler_update nicht null: MySQL hat vermutlich in die temporäre Tabelle geschrieben, diese zum Sortieren gescannt und sie dann noch einmal gescannt, um die Ergebnisse sortiert auszugeben. Schauen wir uns an, was MySQL getan hat, um die Ergebnisse zu sortieren: mysql> SHOW SESSION STATUS LIKE 'Sort%'; +-------------------+-------+ | Variable_name | Value | +-------------------+-------+ | Sort_merge_passes | 0 | | Sort_range | 0 |
78 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
| Sort_rows | 200 | | Sort_scan | 1 | +-------------------+-------+
Wie vorausgesehen, hat MySQL die Zeilen sortiert, indem es eine temporäre Tabelle gescannt hat, die alle Zeilen in der Ausgabe enthielt. Wäre der Wert größer als 200 Zeilen gewesen, dann hätte es unserer Vermutung nach die Sortierung an einer anderen Stelle während der Ausführung der Abfrage vorgenommen. Wir können außerdem erkennen, wie viele temporäre Tabellen MySQL für die Abfrage erzeugt hat: mysql> SHOW SESSION STATUS LIKE 'Created%'; +-------------------------+-------+ | Variable_name | Value | +-------------------------+-------+ | Created_tmp_disk_tables | 0 | | Created_tmp_files | 0 | | Created_tmp_tables | 5 | +-------------------------+-------+
Es ist schön zu sehen, dass die Abfrage nicht die Festplatte für die temporären Tabellen benutzen musste, da dies sehr langsam ist. Ein bisschen seltsam ist es aber schon; sicher hat MySQL für diese eine Abfrage nicht fünf temporäre Tabellen angelegt, oder? Um genau zu sein, benötigt die Abfrage nur eine temporäre Tabelle. Es handelt sich hier um das gleiche Überbleibsel, das uns schon einmal aufgefallen ist. Was ist passiert? Wir führen das Beispiel auf MySQL 5.0.45 aus. In MySQL 5.0 wählt SHOW STATUS tatsächlich Daten aus den INFORMATION_SCHEMA-Tabellen aus, wodurch »Kosten für die Beobachtung« eingeführt werden.7 Das verfälscht die Ergebnisse ein wenig, was Sie erkennen, wenn Sie SHOW STATUS noch einmal ausführen: mysql> SHOW SESSION STATUS LIKE 'Created%'; +-------------------------+-------+ | Variable_name | Value | +-------------------------+-------+ | Created_tmp_disk_tables | 0 | | Created_tmp_files | 0 | | Created_tmp_tables | 6 | +-------------------------+-------+
Sehen Sie, der Wert hat sich wieder erhöht. Der Handler und die anderen Variablen sind gleichermaßen betroffen. Ihre Ergebnisse werden, je nach Ihrer MySQL-Version, etwas anders aussehen. Sie können den gleichen Vorgang – FLUSH STATUS, Ausführen der Abfrage und Ausführen von SHOW STATUS – auch in MySQL 4.1 und älteren Versionen durchführen. Sie brauchen nur einen untätigen Server, da ältere Versionen über globale Zähler verfügen, die von anderen Prozessen geändert werden können.
7 Das Problem der »Kosten für die Beobachtung« wurde in MySQL 5.1 für SHOW SESSION STATUS behoben.
Profiling | 79
Am besten kompensieren Sie die »Kosten für die Beobachtung«, die durch das Ausführen von SHOW STATUS verursacht werden, indem Sie es zweimal ausführen und das zweite Ergebnis vom ersten abziehen. Sie können dies dann von SHOW STATUS abziehen, um die wahren Kosten der Abfrage zu ermitteln. Um exakte Ergebnisse zu erhalten, müssen Sie den Geltungsbereich der Variablen kennen, damit Sie wissen, welche Variablen Kosten für die Beobachtung aufwerfen; manche gelten nur sitzungsweit, andere sind global. Sie können diesen komplizierten Vorgang mit mk-query-profiler automatisieren. Integrieren Sie diese Art des automatischen Profilings in den Datenbankverbindungscode Ihrer Anwendung. Wenn das Profiling aktiviert ist, kann der Verbindungscode den Status vor jeder Abfrage zurücksetzen und die Unterschiede hinterher protokollieren. Alternativ können Sie auf Seitenbasis profilieren und nicht auf Abfragebasis. Beide Strategien eignen sich, um Ihnen zu zeigen, wie viel Arbeit MySQL während der Abfragen erledigt hat.
SHOW PROFILE SHOW PROFILE ist ein Patch, den Jeremy Cole der Community-Version von MySQL hinzugefügt hat. Es gibt ihn dort seit MySQL 5.0.37.8 Das Profiling ist standardmäßig deaktiviert, kann aber auf Sitzungsebene aktiviert werden. Nach dem Aktivieren veranlasst es den MySQL-Server, Informationen über die Ressourcen zu sammeln, die der Server verwendet, um eine Abfrage auszuführen. Setzen Sie dazu die Variable profiling auf 1: mysql> SET profiling = 1;
Führen Sie nun eine Abfrage aus: mysql> SELECT COUNT(DISTINCT actor.first_name) AS cnt_name, COUNT(*) AS cnt -> FROM sakila.film_actor -> INNER JOIN sakila.actor USING(actor_id) -> GROUP BY sakila.film_actor.film_id -> ORDER BY cnt_name DESC; ... 997 rows in set (0.03 sec)
Die Profiling-Daten dieser Abfrage wurden in der Sitzung gespeichert. Um Abfragen zu sehen, die profiliert wurden, verwenden Sie SHOW PROFILES: mysql> SHOW PROFILES\G *************************** 1. row *************************** Query_ID: 1 Duration: 0.02596900 Query: SELECT COUNT(DISTINCT actor.first_name) AS cnt_name,...
Sie gelangen mit der Anweisung SHOW PROFILE an die gespeicherten Profildaten. Wenn Sie diese Anweisung ohne Argument aufrufen, zeigt sie die Statuswerte und Zeitdauer der neuesten Anweisung: 8 Momentan ist SHOW PROFILE noch nicht in den Enterprise-Versionen von MySQL enthalten, selbst in denen nicht, die neuer sind als 5.0.37.
80 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
mysql> SHOW PROFILE; +------------------------+-----------+ | Status | Duration | +------------------------+-----------+ | (initialization) | 0.000005 | | Opening tables | 0.000033 | | System lock | 0.000037 | | Table lock | 0.000024 | | init | 0.000079 | | optimizing | 0.000024 | | statistics | 0.000079 | | preparing | 0.00003 | | Creating tmp table | 0.000124 | | executing | 0.000008 | | Copying to tmp table | 0.010048 | | Creating sort index | 0.004769 | | Copying to group table | 0.0084880 | | Sorting result | 0.001136 | | Sending data | 0.000925 | | end | 0.00001 | | removing tmp table | 0.00004 | | end | 0.000005 | | removing tmp table | 0.00001 | | end | 0.000011 | | query end | 0.00001 | | freeing items | 0.000025 | | removing tmp table | 0.00001 | | freeing items | 0.000016 | | closing tables | 0.000017 | | logging slow query | 0.000006 | +------------------------+-----------+
Jede Zeile repräsentiert eine Zustandsänderung für den Prozess und gibt an, wie lange er in diesem Zustand war. Die Status-Spalte korrespondiert mit der State-Spalte in der Ausgabe von SHOW FULL PROCESSLIST. Die Werte stammen aus der Variablen thd->proc_info, Sie schauen also auf Werte, die direkt aus dem Inneren von MySQL kommen. Sie sind im MySQL-Handbuch dokumentiert, obwohl die meisten intuitiv benannt sind und nicht so schwer zu verstehen sein sollten. Sie können angeben, dass eine Abfrage profiliert werden soll, indem Sie ihre Query_ID aus der Ausgabe von SHOW PROFILES übergeben, und Sie können zusätzliche Ausgabespalten festlegen. Um z.B. die Benutzer- und System-CPU-Zeiten für die vorangegangene Abfrage zu sehen, benutzen Sie den folgenden Befehl: mysql> SHOW PROFILE CPU FOR QUERY 1;
SHOW PROFILE liefert viele Einblicke in die Arbeit, die der Server verrichtet, um eine
Abfrage auszuführen, und kann Ihnen helfen zu verstehen, womit Ihre Abfragen wirklich ihre Zeit verbringen. Einige seiner Beschränkungen bestehen in seinen nichtimplementierten Funktionen, der Unfähigkeit, die Abfragen einer anderen Verbindung zu sehen und zu profilieren, sowie in dem Overhead, der durch das Profiling verursacht wird.
Profiling | 81
Andere Methoden, um MySQL zu profilieren Wir haben Ihnen in diesem Kapitel genügend Details gezeigt, um zu verdeutlichen, wie Sie anhand der internen Statusinformationen von MySQL feststellen können, was im Server passiert. Sie können aber auch mit verschiedenen anderen Statusausgaben von MySQL ein Profiling vornehmen. Weitere nützliche Befehle sind SHOW INNODB STATUS und SHOW MUTEX STATUS. Wir betrachten diese und andere Befehle in Kapitel 13 näher.
Wann können Sie keinen Profiling-Code hinzufügen? Manchmal ist es nicht möglich, Profiling-Code hinzuzufügen oder den Server zu patchen oder gar die Konfiguration des Servers zu ändern. Normalerweise gibt es aber eine Möglichkeit, wenigstens eine Art des Profiling vorzunehmen. Versuchen Sie Folgendes: • Passen Sie Ihre Webserver-Logs so an, dass sie die Wall-Clock-Zeit und die CPUZeit für die einzelnen Anforderungen aufzeichnen. • Verwenden Sie Paket-Sniffer, um Abfragen zu erfassen und zu messen (einschließlich der Netzwerk-Latenz), wenn sie das Netzwerk durchqueren. Frei verfügbare Sniffer sind u.a. mysqlsniffer (http://hackmysql.com/mysqlsniffer) und tcpdump; unter http://forge.mysql.com/snippets/view.php?id=15 finden Sie ein Beispiel für den Einsatz von tcpdump. • Verwenden Sie einen Proxy, wie etwa MySQL Proxy, um Abfragen zu erfassen und zu messen.
Profiling des Betriebssystems Oft ist es ganz sinnvoll, einen Blick in die Statistiken des Betriebssystems zu werfen und zu versuchen herauszufinden, was Betriebssystem und Hardware tun. Das kann nicht nur beim Profiling einer Anwendung helfen, sondern auch bei der Fehlersuche. Dieser Abschnitt ist absichtlich auf Unix-artige Betriebssysteme zugeschnitten, da wir damit am häufigsten arbeiten. Sie können diese Techniken aber auch auf andere Betriebssysteme anwenden, vorausgesetzt, diese liefern Statistiken. Wir benutzen meist die Werkzeuge vmstat, iostat, mpstat und strace. Sie bieten jeweils eine etwas andere Sicht auf eine Kombination aus Prozess, CPU, Speicher und Ein-/Ausgabeaktivität. Diese Werkzeuge stehen auf den meisten Unix-artigen Betriebssystemen zur Verfügung. Wir zeigen im Laufe des Buches Beispiele für ihre Anwendung, vor allem am Ende von Kapitel 7. Seien Sie vorsichtig mit strace unter GNU/Linux auf Produktionsservern. Manchmal scheint es Probleme mit Multi-Thread-Prozessen zu geben, und wir haben damit schon Server zum Absturz gebracht.
82 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Fehlerbehebung bei MySQL-Verbindungen und -Prozessen Eine Gruppe von Werkzeugen, die wir nirgendwo ausführlich betrachten, sind Werkzeuge zum Untersuchen der Netzwerkaktivität und für die grundlegende Fehlerbehebung. Als Beispiel dafür, wie man das erledigen kann, zeigen wir Ihnen, wie Sie eine MySQL-Verbindung zurück zu ihrem Ursprung auf einem anderen Server verfolgen können. Beginnen Sie mit der Ausgabe von SHOW PROCESSLIST in MySQL, und schauen Sie sich die Host-Spalte in einem der Prozesse an. Wir benutzen das folgende Beispiel: *************************** 21. row *************************** Id: 91296 User: web Host: sargon.cluster3:37636 db: main Command: Sleep Time: 10 State: Info: NULL
Die Host-Spalte zeigt, woher die Verbindung stammte und, das ist genauso wichtig, von welchem TCP-Port sie kam. Sie können anhand dieser Information feststellen, welcher Prozess die Verbindung geöffnet hat. Falls Sie Root-Zugang zu sargon haben, können Sie netstat und die Portnummer benutzen, um den Prozess zu ermitteln, der die Verbindung geöffnet hat: root@sargon# netstat -ntp | grep :37636 tcp 0 0 192.168.0.12:37636 192.168.0.21:3306 ESTABLISHED 16072/apache2
Die Prozessnummer und den Namen finden Sie im letzten Feld der Ausgabe: Prozess 16072 startete diese Verbindung, er kam von Apache. Sobald Sie die Prozess-ID kennen, haben Sie die Möglichkeit, viele weitere Dinge über diesen Prozess herauszufinden, wie etwa, welche weiteren Netzwerkverbindungen der Prozess besitzt: root@sargon# netstat -ntp | grep 16072/apache2 tcp 0 0 192.168.0.12:37636 192.168.0.21:3306 ESTABLISHED 16072/apache2 tcp 0 0 192.168.0.12:37635 192.168.0.21:3306 ESTABLISHED 16072/apache2 tcp 0 0 192.168.0.12:57917 192.168.0.3:389 ESTABLISHED 16072/apache2
Es sieht so aus, als hätte dieser Apache-Prozess zwei MySQL-Verbindungen (Port 3306) offen sowie etwas zu Port 389 auf einer anderen Maschine. Was ist Port 389? Es gibt keine Garantie, aber viele Programme benutzen standardisierte Portnummern, wie z.B. MySQL mit dem Standardport 3306. Eine Liste befindet sich oft in /etc/services. Schauen wir also einmal nach, was sie besagt: root@sargon# grep 389 /etc/services ldap 389/tcp # Lightweight Directory Access Protocol ldap 389/udp
Wir wissen zufällig, dass dieser Server LDAP-Authentifizierung einsetzt, LDAP scheint also sinnvoll zu sein. Was können wir noch über Prozess 16072 herausfinden? Mit ps ist
Profiling des Betriebssystems | 83
es ziemlich einfach festzustellen, was der Prozess tut. Das hübsche Muster, das wir grep hinwerfen, hilft uns, die erste Zeile der Ausgabe anzuschauen, die uns die Spaltenüberschriften zeigt: root@sargon# ps -eaf | grep 'UID\|16072' UID PID PPID C STIME TTY TIME CMD apache 16072 22165 0 09:20 ? 00:00:00 /usr/sbin/apache2 -D DEFAULT_VHOST...
Mit dieser Information können Sie potenziell auch andere Probleme finden. Seien Sie z.B. nicht überrascht, wenn Sie feststellen, dass ein Dienst wie LDAP oder NFS Probleme für Apache bereitet und die Seitengenerierung verlangsamt. Mit dem lsof-Befehl können Sie sich auch eine Liste der offenen Dateien eines Prozesses anzeigen lassen. Das liefert Ihnen alle möglichen Informationen, da unter Unix alles eine Datei ist. Wir verzichten hier auf die Ausgabe, weil sie sehr ausführlich ist, aber Sie können lsof | grep 16072 ausführen, um die offenen Dateien des Prozesses zu ermitteln. Mit lsof lassen sich auch Netzwerkverbindungen feststellen, wenn netstat nicht verfügbar ist. So verwendet etwa der folgende Befehl lsof, um ungefähr die gleichen Informationen auszugeben wie netstat. Für den Druck haben wir die Ausgabe ein wenig umformatiert: root@sargon# lsof -i -P | grep 16072 apache2 16072 apache 3u IPv4 25899404 TCP *:80 (LISTEN) apache2 16072 apache 15u IPv4 33841089 TCP sargon.cluster3:37636-> hammurabi.cluster3:3306 (ESTABLISHED) apache2 16072 apache 27u IPv4 33818434 TCP sargon.cluster3:57917-> romulus.cluster3:389 (ESTABLISHED) apache2 16072 apache 29u IPv4 33841087 TCP sargon.cluster3:37635-> hammurabi.cluster3:3306 (ESTABLISHED)
Unter GNU/Linux bildet das /proc-Dateisystem eine weitere wertvolle Hilfe bei der Fehlersuche. Jeder Prozess hat unter /proc sein eigenes Verzeichnis, und Sie finden viele Informationen darüber, wie etwa sein aktuelles Arbeitsverzeichnis, die Speicherbenutzung usw. Apache verfügt außerdem über eine Funktion ähnlich dem Unix-Befehl ps: die URL /server-status/. Falls z.B. in Ihrem Intranet Apache unter http://intranet/ läuft, können Sie sich mit Ihrem Webbrowser zu http://intranet/server-status/ begeben, um festzustellen, was Apache tut. Mit dieser hilfreichen Methode kann man herausfinden, welche URL ein Prozess bedient. Die Seite besitzt eine Legende, die ihre Ausgabe erläutert.
Erweitertes Profiling und Fehlerbehebung Falls Sie einen Prozess genauer erforschen müssen, um festzustellen, was er tut – z.B. weshalb er sich im unterbrechungsfreien Sleep-Status befindet –, verwenden Sie strace -p und/oder gdb -p. Diese Befehle zeigen Systemaufrufe und Backtraces, die Sie genauer darüber in Kenntnis setzen, was der Prozess gerade getan hat, als er hängengeblieben ist. Es gibt viele Möglichkeiten, weshalb ein Prozess hängenbleiben könnte, wie etwa NFSLocking-Dienste, die abstürzen, ein Aufruf an einen entfernten Webservice, der nicht antwortet, usw.
84 |
Kapitel 2: Engpässe finden: Benchmarking und Profiling
Sie können auch Systeme oder Teile von Systemen genauer profilieren, um näher zu erfahren, was sie tun. Wenn Sie wirklich hohe Leistung benötigen und Probleme auftreten, dann werden Sie vielleicht sogar die Interna von MySQL profilieren. Das scheint zwar nicht Ihre Aufgabe zu sein (sondern eher die des MySQL-Entwicklerteams, oder?), aber es kann Ihnen dabei helfen, den Teil des Systems zu isolieren, der Ärger macht. Vielleicht sind Sie nicht gewillt oder in der Lage, das Problem zu lösen, aber zumindest können Sie Ihre Anwendung so gestalten, dass sie die Schwachstelle meidet. Dies sind einige Werkzeuge, die Ihnen nützlich sein könnten: OProfile OProfile (http://oprofile.sourceforge.net) ist ein System-Profiler für Linux. Er besteht aus einem Kernel-Treiber und einem Daemon zum Sammeln von Testdaten, sowie verschiedenen Werkzeugen, mit deren Hilfe Sie die gesammelten Profiling-Daten analysieren können. Er profiliert den gesamten Code, einschließlich der InterruptHandler, des Kernels, der Kernel-Module, der Anwendungen und der Shared Libraries. Wenn eine Anwendung mit Debug-Symbolen kompiliert wurde, kann OProfile die Quelle mit Anmerkungen versehen, aber das ist nicht notwendig; Sie können ein System auch profilieren, ohne alles neu zu kompilieren. Der Overhead ist relativ gering und bewegt sich im Bereich von ein paar Prozent. gprof gprof ist der GNU-Profiler, der Ausführungsprofile von Programmen herstellen kann, die mit der Option -pg kompiliert wurden. Er berechnet die Zeit, die in jeder Routine verbracht wurde. gprof kann Berichte über die Häufigkeit und Dauer von Funktionsaufrufen, ein Aufrufdiagramm und annotierte Quelllistings liefern. Weitere Werkzeuge Es gibt noch viele weitere Werkzeuge, einschließlich spezialisierter und/oder proprietärer Programme. Dazu gehören Intel VTune, der Sun Performance Analyzer (Teil von Sun Studio) und DTrace auf Solaris und anderen Systemen.
Profiling des Betriebssystems | 85
KAPITEL 3
Schema-Optimierung und Indizierung
Das Optimieren eines schlecht gestalteten oder indizierten Schemas kann die Leistung um Größenordnungen verbessern. Falls Sie eine hohe Leistung erwarten, müssen Sie Ihr Schema und die Indizes an die speziellen Abfragen anpassen, die Sie ausführen werden. Sie sollten außerdem die Leistungsanforderungen für die verschiedenen Arten von Abfragen abschätzen, da Änderungen an einer Abfrage oder an einem Teil des Schemas sich auch woanders auswirken können. Eine Optimierung geht oft mit Nebenwirkungen einher. Beispielsweise sorgt das Hinzufügen von Indizes zur Beschleunigung der Datenbereitstellung dafür, dass sich Updates verlangsamen. Ein denormalisiertes Schema wiederum kann einige Arten von Abfragen schneller machen, andere dagegen ausbremsen. Zähler und Summary-Tabellen bilden eine großartige Möglichkeit, um Abfragen zu optimieren, sind aber eventuell in der Wartung recht teuer. Manchmal müssen Sie vielleicht über die Rolle eines Entwicklers hinausgehen und die geschäftlichen Anforderungen hinterfragen, die an Sie gestellt werden. Leute, die keine Experten für Datenbanksysteme sind, schreiben manchmal Geschäftsanforderungen, ohne deren Auswirkungen auf die Leistung zu verstehen. Wenn Sie erklären, dass eine kleine Funktion die Anforderungen an die Server-Hardware verdoppelt, wird man möglicherweise entscheiden, dass man auch ohne diese Funktion auskommen kann. Schema-Optimierung und Indizierung verlangen einen Ansatz, der das Große und Ganze beachtet, sowie Aufmerksamkeit für Details. Sie müssen das ganze System verstehen, um zu verstehen, wie die einzelnen Teile aufeinander wirken. Dieses Kapitel beginnt mit einer Erläuterung der Datentypen und behandelt dann Indizierungsstrategien und Normalisierung. Es endet mit einigen Bemerkungen über Storage-Engines. Wahrscheinlich müssen Sie noch einmal zu diesem Kapitel zurückkommen, nachdem Sie das Kapitel über die Abfragenoptimierung gelesen haben. Viele der hier besprochenen Themen – speziell die Indizierung – können nicht isoliert betrachtet werden. Sie müssen mit Abfragenoptimierung und Server-Tuning vertraut sein, um sinnvolle Entscheidungen über Indizes treffen zu können.
86 |
Optimale Datentypen auswählen MySQL unterstützt eine Vielzahl von Datentypen. Die Auswahl des richtigen Typs zum Speichern Ihrer Daten ist entscheidend für eine gute Performance. Die folgenden einfachen Hinweise sollen Ihnen helfen, bessere Entscheidungen zu treffen – ungeachtet der Frage, welche Arten von Daten Sie speichern: Kleiner ist meist besser Versuchen Sie im Allgemeinen den kleinsten Datentyp zu benutzen, der Ihre Daten korrekt speichern und darstellen kann. Kleinere Datentypen sind normalerweise schneller, da sie weniger Platz auf der Festplatte, im Speicher und im CPU-Cache belegen. Meist erfordern sie auch weniger CPU-Zyklen für die Verarbeitung. Unterschätzen Sie jedoch nicht den Bereich der Werte, die Sie speichern müssen, da das Vergrößern des Datentypbereichs an vielen Stellen in Ihrem Schema unerfreulich und zeitaufwendig ist. Falls Sie sich nicht sicher sind, welcher Datentyp sich für Ihre Zwecke am besten eignet, wählen Sie den kleinsten, der Ihnen möglich erscheint. (Wenn das System nicht sehr ausgelastet ist oder nicht viele Daten enthält oder Sie sich in einer frühen Phase des Entwurfsprozesses befinden, können Sie das hinterher noch ändern.) Einfach ist gut Um Operationen auf einfacheren Datentypen zu verarbeiten, sind typischerweise weniger CPU-Zyklen erforderlich. Zum Beispiel sind Integer-Werte einfacher zu vergleichen als Zeichen, da Zeichensätze und Sortierregeln die Zeichenvergleiche verkomplizieren. Hier sind zwei Beispiele: Sie sollten Daten und Zeiten in den MySQLeigenen Typen anstatt in Strings speichern, und Sie sollten Integer-Werte für IPAdressen verwenden. Wir gehen auf diese Themen später näher ein. Vermeiden Sie NULL, falls möglich Definieren Sie Felder als NOT NULL, falls es sich einrichten lässt. Viele Tabellen enthalten einfach nur aufgrund ihrer Vorgabe »Nullable«-Spalten, auch wenn die Anwendung NULL (also die Abwesenheit eines Wertes) nicht speichern muss. Achten Sie darauf, Spalten als NOT NULL anzugeben, es sei denn, Sie haben ausdrücklich vor, NULL in ihnen zu speichern. Es ist für MySQL schwieriger, Abfragen zu optimieren, die sich auf Nullable-Spalten beziehen, weil diese die Vergleiche von Indizes, Indexstatistiken und Werten deutlich komplizierter machen. Eine Nullable-Spalte belegt mehr Speicherplatz und erfordert in MySQL eine spezielle Verarbeitung. Wenn eine Nullable-Spalte indiziert wird, braucht sie pro Eintrag ein zusätzliches Byte und kann in MyISAM sogar dafür sorgen, dass ein Index fester Größe (wie etwa der Index einer Single-IntegerSpalte) in einen Index variabler Größe konvertiert wird. Selbst wenn Sie die Tatsache eines »kein Wert« in einer Tabelle speichern müssen, müssen Sie nicht unbedingt NULL verwenden. Nehmen Sie stattdessen lieber Null, einen speziellen Wert oder einen leeren String.
Optimale Datentypen auswählen |
87
Die Leistungssteigerung aufgrund der Änderung von NULL-Spalten in NOT NULL ist normalerweise klein. Räumen Sie diesem Vorhaben daher bei einem existierenden Schema keine allzu hohe Priorität ein, es sei denn, Sie wissen, dass diese Spalten Probleme verursachen. Falls Sie dagegen planen, Spalten zu indizieren, vermeiden Sie es, diese nullable zu machen. Der erste Schritt bei der Entscheidung für einen Datentyp für eine Spalte besteht darin, festzustellen, welche allgemeine Klasse von Typen passen würde: numerisch, String, temporal usw. Das ist normalerweise relativ einfach, wir erwähnen hier allerdings einige Sonderfälle, bei denen die Wahl nicht ganz so intuitiv ist. Im nächsten Schritt muss der spezielle Typ gewählt werden. Viele der Datentypen von MySQL können die gleiche Art von Daten speichern, unterscheiden sich aber im möglichen Wertebereich, in der Genauigkeit, die sie zulassen, oder in dem physischen Platz (auf der Festplatte oder im Speicher), den sie erfordern. Manche Datentypen weisen auch besondere Verhaltensweisen oder Eigenschaften auf. So können z.B. eine DATETIME- und eine TIMESTAMP-Spalte die gleiche Art von Daten speichern: Datum und Uhrzeit mit einer Genauigkeit von einer Sekunde. Allerdings belegt TIMESTAMP nur halb so viel Speicherplatz, ist in der Lage, die Zeitzonen zu beachten, und verfügt über besondere Fähigkeiten zur automatischen Aktualisierung. Andererseits ist der Bereich der erlaubten Werte kleiner, und seine besonderen Fähigkeiten können manchmal hinderlich sein. Wir diskutieren hier grundlegende Datentypen. MySQL unterstützt aus Gründen der Kompatibilität viele Aliase, wie etwa INTEGER, BOOL und NUMERIC. Das sind nur Aliase. Sie können verwirrend sein, beeinflussen aber nicht die Leistung.
Ganze Zahlen Es gibt zwei Arten von Zahlen: ganze Zahlen und reelle Zahlen (Zahlen mit einem gebrochenen Anteil). Wenn Sie ganze Zahlen speichern, verwenden Sie einen der IntegerTypen: TINYINT, SMALLINT, MEDIUMINT, INT oder BIGINT. Diese verlangen 8, 16, 24, 32 bzw. 64 Bit Speicherplatz. Sie können Werte von –2(N–1) bis 2(N–1)–1 speichern, wobei N die Anzahl der Bits des von ihnen benutzten Speicherplatzes ist. Integer-Typen können optional das Attribut UNSIGNED aufweisen, das negative Werte verbietet und die obere Grenze der positiven Werte, die Sie speichern können, ungefähr verdoppelt. Beispielsweise kann ein TINYINT UNSIGNED Werte von 0 bis 255 speichern anstatt von –128 bis 127. Vorzeichenbehaftete und vorzeichenlose Typen belegen den gleichen Speicherplatz und weisen die gleiche Leistung auf. Nehmen Sie deshalb das, was für Ihren Datenbereich am besten geeignet ist. Ihre Wahl bestimmt, wie MySQL die Daten im Speicher und auf der Festplatte speichert. Integer-Berechnungen dagegen verwenden im Allgemeinen 64-Bit-BIGINT-Integer-Werte,
88 | Kapitel 3: Schema-Optimierung und Indizierung
selbst auf 32-Bit-Architekturen. (Ausnahmen bilden einige Aggregatfunktionen, die DECIMAL oder DOUBLE einsetzen, um Berechnungen auszuführen.) MySQL erlaubt es Ihnen, eine »Breite« für Integer-Typen anzugeben, z.B. INT(11). Für die meisten Anwendungen hat das keine Bedeutung: Es beschränkt den zulässigen Wertebereich nicht, sondern legt einfach die Anzahl der Zeichen fest, die die interaktiven Werkzeuge von MySQL (wie etwa der Kommandozeilenclient) für die Anzeige reservieren. Bei der Speicherung und bei Berechnungen ist INT(1) identisch mit INT(20). Die Falcon-Storage-Engine unterscheidet sich von den anderen StorageEngines, die MySQL AB anbietet, dahingehend, dass sie Integer-Werte in ihrem eigenen internen Format speichert. Der Benutzer hat keine Kontrolle über die tatsächliche Größe der gespeicherten Daten. Storage-Engines von Drittanbietern, wie etwa Brighthouse, besitzen ebenfalls eigene Speicherformate und Komprimierungsschemata.
Reelle Zahlen Reelle Zahlen sind Zahlen, die einen gebrochenen Anteil aufweisen. Sie eignen sich jedoch nicht nur für gebrochene Zahlen, sondern Sie können DECIMAL auch einsetzen, um Integer-Werte zu speichern, die so groß sind, dass sie nicht in BIGINT passen. MySQL unterstützt sowohl exakte als auch näherungsweise Typen. Die Typen FLOAT und DOUBLE unterstützen näherungsweise Berechnungen mit normaler Fließkommaarithmetik. Falls Sie genau wissen müssen, wie die Fließkommaergebnisse berechnet werden, müssen Sie in der Fließkommaimplementierung Ihrer Plattform nachforschen. Der Typ DECIMAL dient zur Speicherung exakter gebrochener Zahlen. Seit MySQL 5.0 unterstützt DECIMAL exakte Berechnungen. MySQL 4.1 und frühere Versionen verwendeten Fließkommaarithmetik, um Berechnungen mit DECIMAL-Werten durchzuführen. Das konnte aufgrund des Mangels an Genauigkeit zu seltsamen Ergebnissen führen. In diesen Versionen von MySQL war DECIMAL nur ein »Speichertyp«. Seit MySQL 5.0 führt der Server selbst die DECIMAL-Berechnungen durch, weil die CPUs die Berechnungen nicht direkt unterstützen. Fließkommaberechnungen sind etwas schneller, weil die CPU diese nativ ausführt. Sowohl Fließkomma- als auch DECIMAL-Typen erlauben es Ihnen, eine Genauigkeit anzugeben. Für eine DECIMAL-Spalte können Sie die maximal erlaubten Stellen vor und nach dem Dezimalpunkt festlegen. Das hat dann auch Einfluss auf den Platzbedarf der Spalte. MySQL 5.0 und neuere Versionen packen die Stellen in einen Binärstring (neun Stellen pro vier Bytes). Zum Beispiel speichert DECIMAL(18, 9) neun Stellen von jeder Seite des Dezimalpunkts und braucht insgesamt neun Bytes: vier für die Stellen vor dem Dezimalpunkt, eines für den Dezimalpunkt selbst und vier für die Stellen hinter dem Dezimalpunkt.
Optimale Datentypen auswählen |
89
Eine DECIMAL-Zahl in MySQL ab Version 5.0 kann bis zu 65 Stellen besitzen. Frühere MySQL-Versionen hatten eine Grenze von 254 Stellen und speicherten die Werte als ungepackte Strings (ein Byte pro Stelle). Allerdings konnten diese Versionen von MySQL solche großen Zahlen gar nicht in Berechnungen verwenden, weil DECIMAL lediglich ein Speicherformat war; für Berechnungen wurden DECIMAL-Zahlen in DOUBLE-Werte umgewandelt. Es gibt verschiedene Möglichkeiten, die gewünschte Genauigkeit einer Fließkommaspalte festzulegen. Diese Möglichkeiten können allerdings MySQL dazu veranlassen, stillschweigend einen anderen Datentyp zu wählen oder die Werte beim Speichern zu runden. Diese Genauigkeitsspezifikatoren sind nicht standardisiert, so dass wir Ihnen empfehlen, zwar den gewünschten Typ, nicht jedoch die Genauigkeit anzugeben. Fließkommatypen belegen typischerweise weniger Platz als DECIMAL für den gleichen Wertebereich. Eine FLOAT-Spalte verwendet vier Bytes für die Speicherung. DOUBLE belegt acht Bytes und bietet eine größere Genauigkeit und einen größeren Wertebereich. Wie bei den Integer-Werten wählen Sie nur den Speichertyp; MySQL verwendet DOUBLE für seine internen Berechnungen mit Fließkommatypen. Aufgrund der zusätzlichen Platzanforderungen und Berechnungskosten sollten Sie DECIMAL nur dann einsetzen, wenn Sie exakte Werte für gebrochene Zahlen benötigen –
z.B., wenn Sie Finanzdaten speichern.
Stringtypen MySQL unterstützt etliche Stringdatentypen, die jeweils noch viele Variationen bieten. Diese Datentypen haben sich in den Versionen 4.1 und 5.0 stark geändert, was sie noch komplizierter machte. Seit MySQL 4.1 kann jede Stringspalte ihren eigenen Zeichensatz mit eigenen Sortierregeln für diesen Zeichensatz besitzen (Kollation; siehe Kapitel 5 für weitere Informationen zu diesen Themen). Das kann die Performance stark beeinflussen.
VARCHAR- und CHAR-Typen Die beiden wichtigsten Stringtypen sind VARCHAR und CHAR, die Zeichenwerte speichern. Leider ist es schwierig, exakt zu erklären, wie diese Werte auf der Festplatte und im Speicher gespeichert werden, da die Implementierungen von der jeweiligen Storage-Engine abhängen (so benutzt etwa Falcon für fast jeden Datentyp seine eigenen Speicherformate). Wir gehen davon aus, dass Sie InnoDB und/oder MyISAM benutzen. Falls nicht, lesen Sie die Dokumentation Ihrer Storage-Engine. Schauen wir uns an, wie VARCHAR- und CHAR-Werte typischerweise auf der Festplatte gespeichert werden. Beachten Sie, dass eine Storage-Engine einen CHAR- oder VARCHARWert im Speicher anders als auf der Festplatte speichern kann und dass der Server den Wert möglicherweise in noch ein anderes Storage-Engine-Format übersetzt, wenn er ihn von der Storage-Engine bezieht. Hier ist ein allgemeiner Vergleich der beiden Typen:
90 | Kapitel 3: Schema-Optimierung und Indizierung
VARCHAR VARCHAR speichert Zeichenstrings variabler Länge und ist der am weitesten verbrei-
tete Stringdatentyp. Er kann weniger Speicherplatz als die Typen fester Länge beanspruchen, weil er nur so viel Platz benutzt, wie er wirklich braucht (d.h., für kürzere Werte wird weniger Platz benötigt). Eine Ausnahme bildet eine MyISAM-Tabelle, die mit ROW_FORMAT=FIXED erzeugt wurde, bei der also für jede Zeile eine festgelegte Menge an Platz verwendet und daher unter Umständen Platz verschwendet wird. VARCHAR nutzt 1 oder 2 Extrabytes zum Aufzeichnen der Länge des Wertes: 1 Byte, wenn die maximale Länge der Spalte 255 Bytes oder weniger beträgt, und 2 Bytes, wenn es mehr ist. Beim Latin1-Zeichensatz belegt ein VARCHAR(10) bis zu 11 Bytes an Speicherplatz. Ein VARCHAR(1000) kann bis zu 1002 Bytes belegen, da er 2 Bytes für die Längeninformationen braucht. VARCHAR nützt der Leistung, weil es Platz spart. Da die Zeilen jedoch eine variable Länge haben, können sie bei einer Aktualisierung größer werden, was möglicherweise zusätzlichen Aufwand verursacht. Wenn eine Zeile anwächst und nicht mehr an ihre ursprüngliche Stelle passt, hängt es von der Storage-Engine ab, was geschieht. MyISAM könnte z.B. die Zeile fragmentieren, InnoDB muss vielleicht die Seite aufteilen, damit die Zeile hineinpasst. Andere Storage-Engines aktualisieren die vorhandenen Daten möglicherweise niemals. Meist lohnt es sich, VARCHAR zu verwenden, wenn die maximale Spaltenlänge viel größer ist als die durchschnittliche Länge, wenn das Feld selten aktualisiert wird, so dass Fragmentierung kein Problem darstellt, und wenn Sie einen komplexen Zeichensatz wie UTF-8 verwenden, bei dem jedes Zeichen eine variable Anzahl von Bytes zur Speicherung benutzt. Ab Version 5.0 bewahrt MySQL Leerzeichen am Ende, wenn Sie Werte speichern und abrufen. Bis Version 4.1 hat MySQL abschließende Leerzeichen entfernt. CHAR CHAR besitzt eine feste Länge: MySQL reserviert immer genügend Platz für die angegebene Anzahl von Zeichen. Wenn es einen CHAR-Wert speichert, entfernt MySQL alle abschließenden Leerzeichen. (Das gilt auch für VARCHAR bis MySQL 4.1 – CHAR und VARCHAR waren logisch gesehen identisch und unterschieden sich nur im Speicherformat.) Für Vergleichszwecke werden Werte mit Leerzeichen aufgefüllt. CHAR ist sinnvoll, wenn Sie sehr kurze Strings speichern wollen oder wenn alle Werte annähernd gleich lang sind. Zum Beispiel ist CHAR eine gute Wahl für MD5-Werte für Benutzerpasswörter, die immer gleich lang sind. Auch bei Daten, die sich häufig ändern, eignet sich CHAR besser als VARCHAR, da eine Zeile fester Länge nicht von Fragmentierung betroffen ist. Für sehr kurze Spalten ist CHAR ebenfalls effizienter als VARCHAR; ein CHAR(1), das dazu gedacht ist, nur die Werte Y und N aufzunehmen, verwendet in einem ein Byte langen Zeichensatz nur ein Byte,1 ein VARCHAR(1) dagegen würde wegen des Längenbytes zwei Bytes benötigen. 1 Denken Sie daran, dass die Länge in Zeichen und nicht in Bytes festgelegt wird. Ein Multibyte-Zeichensatz kann mehr als ein Byte zur Speicherung der einzelnen Zeichen verlangen.
Optimale Datentypen auswählen |
91
Dieses Verhalten kann ein wenig verwirrend sein, weshalb wir es mit einem Beispiel verdeutlichen. Zuerst erzeugen wir eine Tabelle mit einer einzigen CHAR(10)-Spalte und speichern einige Werte in ihr: mysql> CREATE TABLE char_test( char_col CHAR(10)); mysql> INSERT INTO char_test(char_col) VALUES -> ('string1'), (' string2'), ('string3 ');
Wenn wir die Werte abrufen, wurden die Leerzeichen am Ende entfernt: mysql> SELECT CONCAT("'", char_col, "'") FROM char_test; +----------------------------+ | CONCAT("'", char_col, "'") | +----------------------------+ | 'string1' | | ' string2' | | 'string3' | +----------------------------+
Speichern wir die gleichen Werte in einer VARCHAR(10)-Spalte, erhalten wir beim Abrufen folgendes Ergebnis: mysql> SELECT CONCAT("'", varchar_col, "'") FROM varchar_test; +-------------------------------+ | CONCAT("'", varchar_col, "'") | +-------------------------------+ | 'string1' | | ' string2' | | 'string3 ' | +-------------------------------+
Wie die Daten gespeichert werden, liegt an den Storage-Engines, und nicht alle StorageEngines behandeln Daten fester Länge genauso wie Daten variabler Länge. Die MemoryStorage-Engine verwendet Zeilen mit fester Größe, muss also auch dann den maximal möglichen Platz für jeden Wert reservieren, wenn es sich um ein Feld variabler Länge habelt. Andererseits benutzt Falcon Spalten variabler Länge auch für CHAR-Felder fester Länge. Das Verhalten beim Auffüllen und Abschneiden ist jedoch bei allen Storage-Engines gleich, weil dies der MySQL-Server selbst erledigt. Verwandte Typen zu CHAR und VARCHAR sind BINARY und VARBINARY, die Binär-Strings speichern. Binär-Strings sind herkömmlichen Strings sehr ähnlich, speichern allerdings Bytes anstelle von Zeichen. Auch das Auffüllen geschieht anders: MySQL füllt BINARY-Werte mit \0 (dem Null-Byte) anstatt mit Leerzeichen auf und entfernt beim Abrufen den Auffüllwert nicht.2 Diese Typen sind nützlich, wenn Sie Binärdaten speichern müssen und MySQL die Werte als Byte anstatt als Zeichen vergleichen soll. Der Vorteil der byteweisen Vergleiche besteht in mehr als in der Frage, ob Groß- und Kleinschreibung beachtet wird. MySQL vergleicht BINARY-Strings tatsächlich ein Byte nach dem anderen, entsprechend der nume2 Seien Sie vorsichtig mit dem BINARY-Typ, falls der Wert nach dem Abrufen unverändert bleiben muss. MySQL füllt ihn mit \0 auf die erforderliche Länge auf.
92 | Kapitel 3: Schema-Optimierung und Indizierung
rischen Werte der einzelnen Bytes. Daraus folgt, dass Binärvergleiche viel einfacher sein können als Zeichenvergleiche – und demzufolge auch schneller.
Großzügigkeit ist nicht unbedingt klug Beim Speichern des Wertes 'hello' wird in einer VARCHAR(5)- und in einer VARCHAR(200)Spalte jeweils der gleiche Platz benötigt. Bietet es irgendeinen Vorteil, die kürzere Spalte zu benutzen? Wie es sich zeigt, gibt es einen großen Vorteil. Die größere Spalte kann viel mehr Speicher belegen, weil MySQL oft Speicherbereiche fester Größe reserviert, um Werte intern aufzunehmen. Das erweist sich als besonders ungünstig für Sortierungen oder Operationen, die im Speicher befindliche temporäre Tabellen verwenden. Das gilt auch für Sortierungen, die temporäre Tabellen benutzen, die auf der Festplatte liegen. Die beste Strategie besteht darin, nur so viel Platz zuzuweisen, wie Sie tatsächlich brauchen.
BLOB- und TEXT-Typen BLOB und TEXT sind Stringdatentypen, die große Datenmengen als Binär- bzw. Zeichen-
strings aufnehmen sollen. Es handelt sich bei ihnen eigentlich um Familien von Datentypen: die Zeichentypen sind TINYTEXT, SMALLTEXT, TEXT, MEDIUMTEXT und LONGTEXT, und die Binärtypen sind TINYBLOB, SMALLBLOB, BLOB, MEDIUMBLOB und LONGBLOB. BLOB ist ein Synonym für SMALLBLOB, TEXT ist ein Synonym für SMALLTEXT.
Im Gegensatz zu allen anderen Datentypen behandelt MySQL alle BLOB- und TEXT-Werte als Objekte mit eigener Identität. Storage-Engines speichern sie oft besonders. InnoDB setzt für sie möglicherweise sogar einen separaten »externen« Speicherbereich ein, wenn sie groß sind. Jeder Wert verlangt ein bis vier Byte Speicherplatz in der Zeile und genügend Platz im externen Speicher, um den Wert dann tatsächlich aufzunehmen. Der einzige Unterschied zwischen den BLOB- und den TEXT-Familien besteht darin, dass BLOB-Typen die Binärdaten ohne Sortierregel oder Zeichensatz speichern, während TEXTTypen einen Zeichensatz und eine Sortierregel (Kollation) besitzen. MySQL sortiert BLOB- und TEXT-Spalten anders als andere Typen: Anstatt die vollständige Länge des Strings zu sortieren, sortiert es nur die ersten max_sort_length Bytes solcher Spalten. Wenn Sie nur nach den ersten paar Zeichen sortieren müssen, können Sie entweder die Servervariable max_sort_length verkleinern oder ORDER BY SUBSTRING(Spalte, Länge) verwenden. MySQL kann die vollständige Länge dieser Datentypen nicht indizieren und die Indizes auch nicht für die Sortierung benutzen. (Mehr zu diesen Themen finden Sie weiter hinten in diesem Kapitel.)
Optimale Datentypen auswählen |
93
Wie Sie temporäre Tabellen auf der Festplatte vermeiden Da die Memory-Storage-Engine die Typen BLOB und TEXT nicht unterstützt, müssen Abfragen, die BLOB- oder TEXT-Spalten verwenden und eine implizite temporäre Tabelle benötigen, selbst für nur wenige Zeilen temporäre MyISAM-Tabellen auf der Festplatte benutzen. Das kann zu einem ernsthaften Overhead führen. Auch wenn Sie MySQL so konfigurieren, dass es temporäre Tabellen in einer RAM-Disk speichert, sind viele teure Betriebssystemaufrufe notwendig. (Die Maria-Storage-Engine sollte dieses Problem lindern, indem sie alles im Cache ablegt, nicht nur die Indizes.) Am besten ist es, BLOB- und TEXT-Typen nur dann zu verwenden, wenn Sie sie wirklich brauchen. Wenn Sie sie nicht vermeiden können, dann probieren Sie vielleicht den ORDER BY SUBSTRING(Spalte, Länge)-Trick, um die Werte in Zeichenstrings umzuwandeln, die wiederum temporäre Tabellen im Speicher zulassen. Denken Sie nur daran, einen ausreichend kurzen Teilstring zu verwenden, damit die temporäre Tabelle nicht länger wird als max_heap_table_size oder tmp_table_size, da MySQL die Tabelle ansonsten in eine MyISAM-Tabelle umwandelt, die auf der Festplatte gespeichert wird. Falls die Extra-Spalte von EXPLAIN »Using temporary« enthält, benutzt die Abfrage eine implizite temporäre Tabelle.
ENUM anstelle eines Stringtyps benutzen Manchmal können Sie eine ENUM-Spalte anstelle von herkömmlichen Stringtypen verwenden. Eine ENUM-Spalte kann bis zu 65.535 verschiedene Stringwerte aufnehmen. MySQL speichert sie sehr kompakt, je nach der Anzahl der Werte in der Liste in nur ein oder zwei Bytes gepackt. Es legt jeden Wert intern als Integer ab, der seine Position in der Felddefinitionsliste repräsentiert, und bewahrt die »Lookup-Tabelle«, die die Zuordnung der Zahlen zu den Strings definiert, in der .frm-Datei der Tabelle auf. Hier ist ein Beispiel: mysql> CREATE TABLE enum_test( -> e ENUM('fish', 'apple', 'dog') NOT NULL -> ); mysql> INSERT INTO enum_test(e) VALUES('fish'), ('dog'), ('apple');
Tatsächlich speichern die drei Zeilen Integer-Werte und keine Strings. Sie erkennen die duale Natur der Werte, wenn Sie sie in einem numerischen Kontext abrufen: mysql> SELECT e + 0 FROM enum_test; +-------+ | e + 0 | +-------+ | 1 | | 3 | | 2 | +-------+
Diese Dualität kann fürchterlich verwirrend sein, wenn Sie Zahlen für Ihre ENUM-Konstanten angeben, wie in ENUM('1', '2', '3'). Wir empfehlen Ihnen, dies nicht zu tun.
94 | Kapitel 3: Schema-Optimierung und Indizierung
Überraschend ist weiterhin, dass ein ENUM-Feld anhand der internen Integer-Werte sortiert wird und nicht anhand der Strings selbst: mysql> SELECT e FROM enum_test ORDER BY e; +-------+ | e | +-------+ | fish | | apple | | dog | +-------+
Dem können Sie abhelfen, indem Sie die ENUM-Mitglieder in der Reihenfolge angeben, in der sie sortiert werden sollen. Oder Sie geben mit FIELD( ) explizit eine Sortierreihenfolge in Ihren Abfragen an. Allerdings verhindert dies, dass MySQL den Index für die Sortierung benutzt: mysql> SELECT e FROM enum_test ORDER BY FIELD(e, 'apple', 'dog', 'fish'); +-------+ | e | +-------+ | apple | | dog | | fish | +-------+
Der größte Nachteil von ENUM besteht darin, dass die Liste der Strings fest ist. Das Hinzufügen oder Entfernen von Strings erfordert den Einsatz von ALTER TABLE. Es ist daher wahrscheinlich keine so gute Idee, ENUM als Stringdatentyp zu benutzen, wenn sich die Liste der erlaubten Stringwerte irgendwann in Zukunft ändern wird. MySQL benutzt ENUM in seinen eigenen Privilege-Tabellen, um die Werte Y und N zu speichern. Da MySQL jeden Wert als Integer speichert und eine Suche durchführen muss, um diesen in seine Stringrepräsentation umzuwandeln, verursachen ENUM-Spalten einen gewissen Overhead. Das wird normalerweise durch ihre geringere Größe ausgeglichen, allerdings nicht immer. Es kann insbesondere langsamer sein, eine CHAR- oder VARCHARSpalte zu einer ENUM-Spalte zusammenzufügen als zu einer anderen CHAR- oder VARCHARSpalte. Zur Verdeutlichung haben wir mit einem Benchmark gemessen, wie schnell MySQL solch einen Join mit einer Tabelle in einer unserer Anwendungen durchführt. Die Tabelle besitzt einen relativ breiten Primärschlüssel: CREATE TABLE webservicecalls ( day date NOT NULL, account smallint NOT NULL, service varchar(10) NOT NULL, method varchar(50) NOT NULL, calls int NOT NULL, items int NOT NULL, time float NOT NULL, cost decimal(9,5) NOT NULL,
Optimale Datentypen auswählen |
95
updated datetime, PRIMARY KEY (day, account, service, method) ) ENGINE=InnoDB;
Die Tabelle enthält ungefähr 110.000 Zeilen und ist nur etwa 10 MByte groß, passt also komplett in den Speicher. Die Spalte service enthält 5 einzelne Werte mit einer durchschnittlichen Länge von 4 Zeichen, und die Spalte method enthält 71 Werte mit einer durchschnittlichen Länge von 20 Zeichen. Wir haben eine Kopie dieser Tabelle hergestellt und die Spalten service und method in ENUM umgewandelt: CREATE TABLE webservicecalls_enum ( ... weggelassen ... service ENUM(...values omitted...) NOT NULL, method ENUM(...values omitted...) NOT NULL, ... weggelassen ... ) ENGINE=InnoDB;
Anschließend haben wir die Leistung beim Zusammenführen der Tabellen anhand der Primärschlüsselspalten gemessen. Hier ist die von uns verwendete Abfrage: mysql> SELECT SQL_NO_CACHE COUNT(*) -> FROM webservicecalls -> JOIN webservicecalls USING(day, account, service, method);
Wir variierten diese Abfrage, um die VARCHAR- und ENUM-Spalten in unterschiedlichen Kombinationen zusammenzuführen. Tabelle 3-1 zeigt die Ergebnisse. Tabelle 3-1: Geschwindigkeit beim Zusammenführen von VARCHAR- und ENUM-Spalten Test
Abfragen pro Sekunde
VARCHAR zusammengeführt zu VARCHAR
2,6
VARCHAR zusammengeführt zu ENUM
1,7
ENUM zusammengeführt zu VARCHAR
1,8
ENUM zusammengeführt zu ENUM
3,5
Der Join verläuft nach dem Umwandeln der Spalten in ENUM schneller, allerdings ist das Zusammenführen der ENUM-Spalten zu VARCHAR-Spalten langsamer. Es scheint sich in diesem Fall anzubieten, diese Spalten zu konvertieren, solange sie nicht zu VARCHAR-Spalten zusammengeführt werden müssen. Das Umwandeln der Spalten bringt jedoch noch einen Vorteil mit sich: Laut der Data_length-Spalte aus SHOW TABLE STATUS wurde die Tabelle nach dem Konvertieren dieser beiden Spalten nach ENUM um etwa 1/3 kleiner. Manchmal ist das sogar dann ganz günstig, wenn die ENUM-Spalten zu VARCHAR-Spalten zusammengeführt werden müssen. Der Primärschlüssel ist nach der Konvertierung ebenfalls nur noch etwa halb so groß. Da es sich hier um eine InnoDB-Tabelle handelt, würde die Verringerung der Primärschlüsselgröße dazu führen, dass möglicherweise vorhandene Indizes ebenfalls viel kleiner werden. Wir erklären das später noch genauer.
96 | Kapitel 3: Schema-Optimierung und Indizierung
Datums- und Zeittypen MySQL verfügt über viele Typen für verschiedene Arten von Datums- und Zeitwerten, wie etwa YEAR und DATE. Die feinste Auflösung, die MySQL für eine Zeit speichern kann, beträgt eine Sekunde. Es kann allerdings temporäre Berechnungen mit Mikrosekundenauflösung durchführen, und wir zeigen Ihnen auch, wie Sie die Speicherbeschränkungen umgehen. Für die meisten der temporalen Typen gibt es keine Alternativen, es ist also nicht die Frage, welches die beste Wahl ist. Die einzige Frage ist, was Sie tun, wenn Sie sowohl ein Datum als auch eine Uhrzeit speichern müssen. MySQL bietet für diesen Zweck zwei sehr ähnliche Datentypen: DATETIME und TIMESTAMP. Für viele Anwendungen funktionieren beide, manchmal ist jedoch ein Typ besser als der andere. Werfen wir einen Blick darauf: DATETIME
Dieser Typ kann bei einer Genauigkeit von einer Sekunde einen großen Wertebereich, und zwar vom Jahr 1001 bis zum Jahr 9999, aufnehmen. Er speichert das Datum und die Uhrzeit, gepackt in einen Integer-Wert im Format YYYYMMDDHHMMSS, unabhängig von der Zeitzone. Dazu sind acht Bytes Speicherplatz nötig. Standardmäßig zeigt MySQL DATETIME-Werte in einem sortierbaren, unmissverständlichen Format an, also etwa 2008-01-16 22:37:08. Dies ist die ANSI-Standardmethode zum Darstellen von Datums- und Uhrzeitangaben. TIMESTAMP
Wie der Name vermuten lässt, speichert der Typ TIMESTAMP die Anzahl der Sekunden, die seit Mitternacht des 1. Januar 1970 (Greenwich Mean Time) vergangen sind – das ist also identisch mit dem Unix-Zeitstempel. TIMESTAMP benutzt nur vier Bytes zur Speicherung, umfasst daher einen deutlich kleineren Bereich als DATETIME: von 1970 bis in die Mitte des Jahres 2038. MySQL bietet die Funktionen FROM_UNIXTIME( ) und UNIX_TIMESTAMP( ), um einen Unix-Zeitstempel in ein Datum umzuwandeln und umgekehrt. Neuere MySQL-Versionen formatieren TIMESTAMP-Werte genau wie DATETIME-Werte, ältere MySQL-Versionen dagegen zeigen sie ohne Interpunktion zwischen den Teilen an. Dieser Unterschied besteht nur in der Anzeigeformatierung; das TIMESTAMPSpeicherformat ist in allen MySQL-Versionen gleich. Welchen Wert ein TIMESTAMP anzeigt, hängt von der Zeitzone ab. MySQL-Server, Betriebssystem und Clientverbindungen besitzen jeweils ihre eigenen Zeitzoneneinstellungen. Ein TIMESTAMP, der den Wert 0 speichert, zeigt tatsächlich den 1969-12-31 19:00:00 in Eastern Standard Time an, eine Zeitzone, die fünf Stunden Unterschied zu GMT hat. TIMESTAMP besitzt besondere Eigenschaften, die DATETIME nicht hat. Standardmäßig setzt MySQL die erste TIMESTAMP-Spalte auf die aktuelle Zeit, wenn Sie eine Zeile ein-
Optimale Datentypen auswählen |
97
fügen, ohne einen Wert für die Spalte anzugeben.3 MySQL aktualisiert außerdem den Wert der ersten TIMESTAMP-Spalte, wenn Sie die Zeile aktualisieren, es sei denn, Sie weisen in der UPDATE-Anweisung ausdrücklich einen Wert zu. Sie können das Verhalten beim Einfügen und bei der Aktualisierung für jede TIMESTAMP-Spalte konfigurieren. Schließlich sind TIMESTAMP-Spalten standardmäßig NOT NULL, wodurch sie sich von jedem anderen Datentyp unterscheiden. Abgesehen von dem besonderen Verhalten gilt, dass Sie im Allgemeinen TIMESTAMP benutzen sollten, wenn dies möglich ist, da es effizienter mit dem Platz umgeht als DATETIME. Manchmal speichern Leute die Unix-Zeitstempel als Integer-Werte, das bringt aber normalerweise gar nichts. Da dieses Format im Umgang oft weniger bequem ist, raten wir davon ab. Was ist, wenn Sie einen Datums- und Zeitwert mit einer Auflösung von unter einer Sekunde speichern müssen? MySQL besitzt momentan keinen passenden Datentyp dafür, aber Sie können Ihr eigenes Speicherformat einsetzen: Verwenden Sie den Datentyp BIGINT, und speichern Sie den Wert als Zeitstempel in Mikrosekunden, oder benutzen Sie DOUBLE, und speichern Sie den gebrochenen Anteil hinter den Sekunden nach dem Dezimalpunkt. Beide Ansätze funktionieren gut.
Bit-gepackte Datentypen MySQL verfügt über einige Speichertypen, die einzelne Bits in einem Wert verwenden, um Daten kompakt zu speichern. Technisch gesehen sind all diese Typen Stringtypen, ungeachtet des zugrunde liegenden Speicherformats und der Manipulationen: BIT
Vor MySQL 5.0 ist BIT einfach nur ein Synonym für TINYINT. Seit MySQL 5.0 jedoch ist es ein völlig anderer Datentyp mit besonderen Eigenschaften. Wir besprechen das neue Verhalten hier. Sie können eine BIT-Spalte einsetzen, um einen oder mehrere Wahr/falsch-Werte in einer einzigen Spalte zu speichern. BIT(1) definiert ein Feld, das ein einziges Bit enthält, BIT(2) speichert zwei Bits usw. Die maximale Länge einer BIT-Spalte beträgt 64 Bits. Das Verhalten von BIT variiert zwischen den verschiedenen Storage-Engines. MyISAM packt die Spalten zum Zwecke der Speicherung zusammen, so dass 17 einzelne BIT-Spalten für die Speicherung nur 17 Bits erfordern (vorausgesetzt, keine dieser Spalten erlaubt NULL). MyISAM rundet das auf drei Bytes für die Speicherung. Andere Storage-Engines, wie etwa Memory und InnoDB, speichern jede Spalte als kleinsten Integer-Typ, der groß genug ist, um die Bits aufzunehmen. Sie sparen also keinen Speicherplatz.
3 Die Regeln für das Verhalten von TIMESTAMP sind komplex und haben sich in den verschiedenen MySQL-Versionen geändert, Sie müssen also sicherstellen, dass Sie das gewünschte Verhalten bekommen. Normalerweise ist es eine gute Idee, die Ausgabe von SHOW CREATE TABLE zu untersuchen, nachdem Sie Änderungen an den TIMESTAMP-Spalten vorgenommen haben.
98 | Kapitel 3: Schema-Optimierung und Indizierung
MySQL behandelt BIT als Stringtyp, nicht als numerischen Typ. Wenn Sie einen BIT(1)-Wert abrufen, ist das Ergebnis ein String, der Inhalt ist aber der Binärwert 0 oder 1, nicht der ASCII-Wert »0« oder »1«. Falls Sie jedoch den Wert in einem numerischen Kontext abrufen, ist das Ergebnis die Zahl, in die der Bitstring konvertiert wird. Denken Sie daran, wenn Sie das Ergebnis mit einem anderen Wert vergleichen müssen. Falls Sie z.B. den Wert b'00111001' (das binäre Äquivalent von 57) in einer BIT(8)-Spalte speichern und ihn dann abrufen, erhalten Sie den String, der den Zeichencode 57 enthält. Das ist zufällig der ASCII-Zeichencode für »9«. In einem numerischen Kontext dagegen erhalten Sie den Wert 57: mysql> CREATE TABLE bittest(a bit(8)); mysql> INSERT INTO bittest VALUES(b'00111001'); mysql> SELECT a, a + 0 FROM bittest; +------+-------+ | a | a + 0 | +------+-------+ | 9 | 57 | +------+-------+
Das kann sehr verwirrend sein, setzen Sie deshalb BIT mit Bedacht ein. Wir denken, dass es für die meisten Anwendungen am besten ist, diesen Typ zu vermeiden. Falls Sie einen Wahr/falsch-Wert in einem einzigen Bit speichern wollen, besteht eine weitere Möglichkeit darin, eine nullable CHAR(0)-Spalte anzulegen. Diese Spalte ist in der Lage, entweder die Abwesenheit eines Wertes (NULL) oder einen Wert der Länge null (den leeren String) zu speichern. SET
Falls Sie viele Wahr/falsch-Werte speichern müssen, dann sollten Sie darüber nachdenken, ob Sie viele Spalten mit dem MySQL-eigenen SET-Datentyp zu einer kombinieren. MySQL stellt den Datentyp SET intern als gepackte Menge aus Bits dar. Er nutzt den Speicher effizient aus und kann mithilfe von MySQL-Funktionen wie FIND_IN_SET( ) und FIELD( ) leicht in Abfragen genutzt werden. Der größte Nachteil sind die Kosten für das Ändern der Spaltendefinition: Es erfordert ein ALTER TABLE, das bei großen Tabellen sehr teuer ist (weiter hinten in diesem Kapitel lernen Sie allerdings eine Lösung dafür kennen). Im Allgemeinen können Sie auch keine Indizes für Suchen in SET-Spalten benutzen. Bitweise Operationen auf Integer-Spalten Eine Alternative zu SET besteht darin, ein Integer als gepacktes Feld aus Bits zu verwenden. So können Sie z.B. acht Bits in ein TINYINT packen und sie mit bitweisen Operatoren manipulieren. Sie vereinfachen dies, indem Sie benannte Konstanten für jedes Bit in Ihrem Anwendungscode definieren. Der größte Vorteil dieses Ansatzes gegenüber SET ist, dass Sie die »Aufzählung«, die das Feld repräsentiert, ohne ALTER TABLE ändern können. Nachteilig ist, dass die Abfragen schwieriger zu schreiben und zu verstehen sind (was bedeutet es, wenn Bit 5 gesetzt ist?). Manche Leute kommen mit bitweisen Manipulationen gut zurecht, andere nicht; ob Sie diese Technik also ausprobieren, ist vor allem eine Frage Ihrer persönlichen Vorlieben. Optimale Datentypen auswählen |
99
Eine Beispielanwendung für gepackte Bits ist eine Zugriffskontrollliste (Access Control List; ACL), die Berechtigungen speichert. Jedes Bit oder SET-Element repräsentiert einen Wert wie CAN_READ, CAN_WRITE oder CAN_DELETE. Falls Sie eine SET-Spalte benutzen, erlauben Sie es MySQL, die Bit-zu-Wert-Zuordnung in der Spaltendefinition zu speichern. Bei einer Integer-Spalte speichern Sie die Zuordnung im Anwendungscode. So würden die Abfragen bei einer SET-Spalte aussehen: mysql> CREATE TABLE acl ( -> perms SET('CAN_READ', 'CAN_WRITE', 'CAN_DELETE') NOT NULL -> ); mysql> INSERT INTO acl(perms) VALUES ('CAN_READ,CAN_DELETE'); mysql> SELECT perms FROM acl WHERE FIND_IN_SET('CAN_READ', perms); +---------------------+ | perms | +---------------------+ | CAN_READ,CAN_DELETE | +---------------------+
Hätten Sie ein Integer verwendet, könnten Sie das Beispiel folgendermaßen schreiben: mysql> SET @CAN_READ := 1 << 0, -> @CAN_WRITE := 1 << 1, -> @CAN_DELETE := 1 << 2; mysql> CREATE TABLE acl ( -> perms TINYINT UNSIGNED NOT NULL DEFAULT 0 -> ); mysql> INSERT INTO acl(perms) VALUES(@CAN_READ + @CAN_DELETE); mysql> SELECT perms FROM acl WHERE perms & @CAN_READ; +-------+ | perms | +-------+ | 5 | +-------+
Wir haben hier Variablen eingesetzt, um die Werte zu defnieren, Sie können in Ihrem Code aber auch Konstanten benutzen.
Bezeichner wählen Es ist sehr wichtig, für eine Bezeichnerspalte einen guten Datentyp zu wählen. Sie werden diese Spalten eher mit anderen Werten vergleichen (z.B. in Joins) und sie für Lookups verwenden als andere Spalten. Und vermutlich werden Sie sie in anderen Tabellen als Fremdschlüssel einsetzen, so dass Sie beim Festlegen eines Datentyps für eine Bezeichnerspalte den Typ auch in den zugehörigen Tabellen wählen werden. (Wie wir weiter vorn in diesem Kapitel demonstriert haben, bietet es sich an, in zusammengehörenden Tabellen den gleichen Datentyp zu wählen, da Ihnen dies auch bei Joins entgegenkommt.) Wenn Sie einen Typ für eine Bezeichnerspalte wählen, müssen Sie nicht nur den Speichertyp beachten, sondern auch, wie MySQL Berechnungen und Vergleiche mit diesem Typ ausführt. Beispielsweise speichert MySQL ENUM- und SET-Typen als Integer, konvertiert sie aber in Strings, wenn es Vergleiche in einem Stringumfeld durchführt.
100 | Kapitel 3: Schema-Optimierung und Indizierung
Haben Sie sich für einen Typ entschieden, dann nehmen Sie diesen Typ auch in allen zugehörigen Tabellen. Die Typen sollten genau übereinstimmen, einschließlich solcher Eigenschaften wie UNSIGNED.4 Das Mischen unterschiedlicher Datentypen kann zu Performance-Problemen führen. Und selbst dann, wenn das nicht so ist, könnten implizite Typkonvertierungen im Laufe von Vergleichen Fehler verursachen, die nur schwer zu finden sind. Solche Fehler können sogar später noch auftauchen, wenn Sie schon längst vergessen haben, dass Sie unterschiedliche Datentypen vergleichen. Wählen Sie die kleinste Größe, die Ihren erforderlichen Wertebereich aufnehmen kann, und lassen Sie notfalls Raum für ein künftiges Wachstum. Falls Sie z.B. eine state_idSpalte haben, in der die Namen von US-Bundesstaaten gespeichert sind, benötigen Sie nicht Tausende oder Millionen Werte: Nehmen Sie deshalb kein INT. Ein TINYINT sollte ausreichen und ist drei Bytes kleiner. Wenn Sie diesen Wert als Fremdschlüssel in anderen Tabellen benutzen, können drei Bytes schon einen großen Unterschied machen. Integer-Typen Integer sind normalerweise die beste Wahl für Bezeichner, da sie schnell sind und mit AUTO_INCREMENT funktionieren. ENUM und SET
Die Typen ENUM und SET stellen im Allgemeinen eine schlechte Wahl für Bezeichner dar, obwohl sie ganz gut für statische »Definitionstabellen« sein können, die Statusoder »Typ«-Werte enthalten. ENUM- und SET-Spalten eignen sich zum Aufnehmen von Informationen wie dem Status einer Bestellung, einem Produkttyp oder dem Geschlecht einer Person. Falls Sie z.B. ein ENUM-Feld benutzen, um den Typ eines Produkts zu definieren, wollen Sie möglicherweise eine Lookup-Tabelle haben, die über einen Primärschlüssel mit einem identischen ENUM-Feld verbunden ist. (Sie könnten in der Lookup-Tabelle Spalten für beschreibenden Text hinzufügen, um ein Glossar zu generieren oder um sinnvolle Bezeichnungen in einem Pulldown-Menü auf einer Website anzubieten.) In diesem Fall werden Sie ENUM als Bezeichner verwenden, für die meisten anderen Aufgaben sollten Sie dies hingegen vermeiden. Stringtypen Vermeiden Sie nach Möglichkeit Stringtypen für Bezeichner, da sie eine Menge Platz beanspruchen und im Allgemeinen langsamer sind als Integer-Typen. Seien Sie besonders vorsichtig, wenn Sie Stringbezeichner bei MyISAM-Tabellen einsetzen. MyISAM verwendet standardmäßig gepackte Indizes für Strings, wodurch sich Suchen deutlich verlangsamen. In unseren Tests haben wir mit gepackten Indizes unter MyISAM eine sechsmal langsamere Leistung festgestellt.
4 Wenn Sie die InnoDB-Storage-Engine benutzen, sind Sie möglicherweise gar nicht in der Lage, Fremdschlüssel zu erzeugen, wenn die Datentypen nicht exakt zueinander passen. Die resultierende Fehlermeldung »ERROR 1005 (HY000): Can’t create table« kann je nach Kontext verwirrend sein, und oft wird in MySQL-Mailinglisten danach gefragt. (Eigenartigerweise kann man Fremdschlüssel zwischen VARCHAR-Spalten unterschiedlicher Längen anlegen.)
Optimale Datentypen auswählen | 101
Seien Sie außerdem vorsichtig mit vollständig »zufälligen« Strings, wie sie etwa von MD5( ), SHA1( ) oder UUID( ) erzeugt werden. Jeder neue Wert, den Sie mit ihnen generieren, wird beliebig über einen großen Raum verteilt. Dadurch verlangsamen sich INSERT- und einige Arten von SELECT-Abfragen:5 • Sie verlangsamen INSERT-Abfragen, weil der eingefügte Wert an eine zufällige Stelle in den Indizes gelangen muss. Das verursacht Seitenaufteilungen, zufällige Festplattenzugriffe und eine Fragmentierung des Cluster-Index bei ClusterStorage-Engines. • Sie verlangsamen SELECT-Abfragen, weil logisch benachbarte Zeilen weit über die Festplatte und im Speicher verstreut werden. • Zufällige Werte sorgen bei allen Arten von Abfragen dafür, dass die Caches nur schlecht funktionieren, da sie die Lokalitätseigenschaft vereiteln, die für das Funktionieren von Caches verantwortlich ist. Wenn der gesamte Datensatz gleichermaßen »heiß« ist, dann bringt es keine Vorteile, bestimmte Teile der Daten im Cache abzulegen. Und wenn der Arbeitssatz nicht in den Speicher passt, dann weist der Cache viele Lücken auf. Falls Sie UUID-Werte speichern, sollten Sie die Bindestriche entfernen oder, besser noch, die UUID-Werte mit UNHEX( ) in 16-Byte-Zahlen konvertieren und diese in einer BINARY(16)-Spalte speichern. Sie können die Werte im Hexadezimalformat mit der Funktion HEX( ) abrufen. Werte, die von UUID( ) generiert wurden, haben andere Eigenschaften als solche, die von einer kryptografischen Hash-Funktion wie SHA1( ) erzeugt wurden: Die UUIDWerte sind ungleichmäßig verteilt und in gewisser Weise sequenziell. Sie sind allerdings nicht so gut wie ein monoton ansteigender Integer-Wert.
Besondere Arten von Daten Manche Arten von Daten korrespondieren nicht direkt mit den verfügbaren eingebauten Typen. Ein Zeitstempel mit einer Auflösung von unter einer Sekunde ist ein Beispiel dafür; wir haben Ihnen weiter vorn in diesem Kapitel bereits einige Möglichkeiten für die Speicherung solcher Daten gezeigt. Ein weiteres Beispiel ist eine IP-Adresse. Oft werden VARCHAR(15)-Spalten verwendet, um IP-Adressen zu speichern. Eine IP-Adresse ist aber eigentlich ein vorzeichenloser 32-BitInteger-Wert, kein String. Die Dotted-Quad-Notation stellt nur eine Möglichkeit dar, sie so zu schreiben, dass Menschen sie leichter lesen können. Sie sollten IP-Adressen als vorzeichenlose Integer-Werte speichern. MySQL bietet die Funktionen INET_ATON( ) und INET_NTOA( ) für Konvertierungen zwischen den beiden Darstellungen. Künftige Versionen von MySQL enthalten dann vielleicht einen eigenen Datentyp für IP-Adressen. 5 Andererseits können solche pseudozufälligen Werte bei sehr großen Tabellen mit vielen Schreiboperationen dabei helfen, »Hot-Spots« zu eliminieren.
102 | Kapitel 3: Schema-Optimierung und Indizierung
Hüten Sie sich vor automatisch generierten Schemata Wir haben die wichtigsten Überlegungen in Bezug auf Datentypen behandelt (einige mit ernsthaften, andere mit weniger starken Auswirkungen auf die Performance), sind aber noch nicht auf die Schrecken von automatisch generierten Schemata eingegangen. Schlecht geschriebene Schema-Migrationsprogramme und Programme, die automatisch Schemata generieren, können schwerwiegende Performance-Probleme hervorrufen. Einige Programme benutzen große VARCHAR-Felder für alles oder verwenden unterschiedliche Datentypen für Spalten, die in Joins verglichen werden. Überprüfen Sie ein Schema auf jeden Fall besonders gründlich, wenn es automatisch erzeugt wurde. Objektrelationale Abbildungssysteme (Object-relational Mapping; ORM) sowie die »Frameworks«, die sie einsetzen, sind ein weiterer Performance-Albtraum. Einige dieser Systeme erlauben es Ihnen, beliebige Arten von Daten in einem beliebigen Typ von BackendDatenspeicher zu speichern, was normalerweise bedeutet, dass sie gar nicht darauf ausgelegt sind, die Stärken dieser Datenspeicher auszunutzen. Manchmal speichern sie jede Eigenschaft eines Objekts in einer eigenen Zeile, wobei sie sogar eine zeitstempelbasierte Versionierung einsetzen, es also mehrere Versionen jeder Eigenschaft gibt! Ein solches Design mag Entwicklern gefallen, die damit objektorientiert arbeiten können, ohne darüber nachdenken zu müssen, wie die Daten gespeichert werden. Anwendungen jedoch, die ihre »Komplexität vor den Entwicklern verstecken«, skalieren normalerweise nicht besonders gut. Wir empfehlen Ihnen, genau nachzudenken, bevor Sie Leistung gegen Entwicklungsproduktivität eintauschen. Führen Sie außerdem immer Tests an realistischen Datenmengen durch, damit Ihnen Leistungsprobleme nicht zu spät auffallen.
Grundlagen der Indizierung Indizes sind Datenstrukturen, die MySQL dabei helfen, Daten effizient abzurufen. Sie sind für eine gute Leistung entscheidend, allerdings werden sie oft vergessen oder missverstanden. Indizierung bildet deshalb den Hauptgrund für viele auftretende Performance-Probleme. Deshalb behandeln wir dieses Thema bereits so früh in diesem Buch – sogar noch vor der Abfragenoptimierung. Indizes (in MySQL auch »Schlüssel« genannt) werden mit zunehmender Datenmenge immer wichtiger. Kleine, leicht ladbare Datenbanken laufen oft auch ohne passende Indizes gut. Wenn die Datenmengen dann aber größer werden, kann die Leistung sehr schnell einbrechen. Am einfachsten verstehen Sie, wie ein Index in MySQL funktioniert, wenn Sie an den Index in einem Buch denken. Um festzustellen, an welcher Stelle in einem Buch ein Thema besprochen wird, schauen Sie in den Index. Dieser verrät Ihnen die Seitenzahlen, an denen der Begriff auftaucht.
Grundlagen der Indizierung | 103
MySQL setzt Indizes auf ähnliche Weise ein. Es durchsucht die Datenstruktur eines Index nach einem Wert. Wenn es einen Treffer entdeckt, kann es die Zeile suchen, die diesen Treffer enthält. Nehmen Sie an, Sie führen folgende Abfrage durch: mysql> SELECT first_name FROM sakila.actor WHERE actor_id = 5;
Es gibt einen Index für die Spalte actor_id, MySQL verwendet also den Index, um Zeilen zu finden, deren actor_id gleich 5 ist. Mit anderen Worten, es führt eine Suche in den Werten des Index aus und liefert alle Zeilen zurück, die den angegebenen Wert enthalten. Ein Index enthält Werte aus einer oder mehreren bestimmten Spalten in einer Tabelle. Wenn Sie mehr als eine Spalte indizieren, dann ist die Spaltenreihenfolge sehr wichtig, weil MySQL nur auf einem ganz links gelegenen Präfix des Index effizient suchen kann. Wie Sie sehen werden, ist das Erzeugen eines Index über zwei Spalten nicht das Gleiche wie das Erzeugen zweier getrennter Indizes über jeweils eine Spalte.
Arten von Indizes Es gibt viele Arten von Indizes, die sich jeweils für unterschiedliche Zwecke eignen. Indizes werden auf der Storage-Engine-Ebene implementiert, nicht auf der Serverebene. Daher sind sie nicht standardisiert: Die Indizierung funktioniert in jeder Engine etwas anders, und die einzelnen Engines unterstützen auch nicht unbedingt alle Indexarten. Selbst wenn mehrere Engines den gleichen Indextyp unterstützen, implementieren sie ihn möglicherweise intern unterschiedlich. Unter dieser Maßgabe wollen wir uns nun die Indexarten anschauen, für die MySQL momentan Unterstützung bietet, und ihre Vor- und Nachteile betrachten.
B-Baum-Indizes Wenn Informatiker über Indizes reden, ohne einen Typ zu erwähnen, meinen sie mit großer Wahrscheinlichkeit einen B-Baum-Index (B-Tree-Index), der typischerweise eine B-Baum-Datenstruktur benutzt, um seine Daten zu speichern.6 Die meisten der MySQLStorage-Engines unterstützen diesen Indextyp. Eine Ausnahme bildet die ArchiveEngine: Sie hat bis MySQL 5.1 überhaupt keine Indizes unterstützt. Seitdem erlaubt sie eine einzelne indizierte AUTO_INCREMENT-Spalte. Wir verwenden den Begriff »B-Baum« für diese Indizes, weil MySQL ihn in CREATE TABLE und anderen Anweisungen verwendet. Intern können Storage-Engines jedoch auch andere Speicherstrukturen benutzen. Beispielsweise setzt die NDB Cluster-StorageEngine eine T-Baum-Datenstruktur für solche Indizes ein, nennt sie aber BTREE.
6 Viele Storage-Engines benutzen tatsächlich einen B+Baum-Index, in dem jeder Blattknoten einen Verweis auf den nächsten enthält, um ein schnelles Absteigen durch die Knoten zu ermöglichen. Ausführliche Erläuterungen zu B-Baum-Indizes finden Sie in der Informatik-Fachliteratur.
104 | Kapitel 3: Schema-Optimierung und Indizierung
Storage-Engines speichern B-Baum-Indizes auf verschiedene Weise auf der Festplatte, wodurch die Leistung beeinflusst werden kann. So benutzt etwa MyISAM eine Präfixkomprimierungstechnik, die Indizes verkleinert, während InnoDB die Indizes unkomprimiert lässt, weil es für einige seiner Optimierungen keine komprimierten Indizes benutzen kann. Außerdem verweisen MyISAM-Indizes auf die indizierten Zeilen anhand der physischen Positionen der gespeicherten Zeilen, während InnoDB auf sie anhand ihrer Primärschlüsselwerte verweist. Jede Variante hat ihre Vor- und Nachteile. Der grundsätzliche Gedanke hinter einem B-Baum besteht darin, dass alle Werte in ihrer Reihenfolge gespeichert werden und jedes Blatt den gleichen Abstand von der Wurzel aufweist. Abbildung 3-1 zeigt eine abstrakte Darstellung eines B-Baums, die ungefähr dem entspricht, wie die InnoDB-Indizes funktionieren (InnoDB verwendet eine B+BaumStruktur). MyISAM verwendet eine andere Struktur, die Prinzipien sind aber ähnlich. Wert in Seite Zeiger auf Kindseite Zeiger von höher gelegener Knotenseite
Zeiger von höher gelegener Knotenseite
Schlüssel1
SchlüsselN
Blattseite: Werte < Schlüssel1 Wert1.1 Wert1.2
Wert1.m
Zeiger auf Daten (variiert zwischen den Storage-Engines)
Verweis auf nächstes Blatt Schlüssel1 <= Wert < Schlüssel2 Wert2.1 Wert2.2
Wert2.m Werte>= SchlüsselN WertN.1 WertN.2
WertN.m
Logische Seite. Größe hängt von der Storage-Engine ab. 16K für InnoDB.
Abbildung 3-1: Ein Index, der auf einer B-Baum-Struktur (technisch gesehen, einer B+Baum-Struktur) aufbaut
Ein B-Baum-Index beschleunigt den Datenzugriff, weil die Storage-Engine nicht die gesamte Tabelle scannen muss, um die gewünschten Daten zu finden. Stattdessen beginnt sie beim Wurzelknoten (in der Abbildung nicht zu sehen). Die Positionen im Wurzelknoten enthalten Zeiger auf Kindknoten, und die Storage-Engine folgt diesen Zeigern. Sie findet den richtigen Zeiger, indem sie sich die Werte in den Knotenseiten anschaut, die die oberen und unteren Grenzen der Werte in den Kindknoten definieren. Schließlich stellt die Storage-Engine entweder fest, dass der gewünschte Wert nicht existiert, oder erreicht erfolgreich eine Blattseite.
Grundlagen der Indizierung | 105
Blattseiten sind besonders, weil sie anstelle von Zeigern auf andere Seiten Zeiger auf die indizierten Daten enthalten. (Bei den verschiedenen Storage-Engines gibt es unterschiedliche Arten von »Zeigern« auf die Daten.) Unsere Illustration zeigt nur eine Knotenseite und ihre Blattseiten, es kann aber auch viele Ebenen aus Knotenseiten zwischen der Wurzel und den Blättern geben. Die Tiefe des Baums hängt davon ab, wie groß die Tabelle ist. Da B-Bäume die indizierten Spalten der Reihe nach speichern, eignen sie sich gut zum Suchen von Datenbereichen. Beim Absteigen durch den Baum auf der Suche nach einem Index auf ein Textfeld durchläuft man z.B. die Werte in alphabetischer Reihenfolge, so dass es effizient ist, »alle zu suchen, deren Namen mit den Buchstaben I bis K beginnen«. Nehmen Sie an, Sie haben die folgende Tabelle: CREATE TABLE People ( last_name varchar(50) not null, first_name varchar(50) not null, dob date not null, gender enum('m', 'f') not null, key(last_name, first_name, dob) );
Der Index enthält für jede Zeile in der Tabelle die Werte aus den Spalten last_name, first_name und dob. Abbildung 3-2 verdeutlicht, wie der Index die Daten anordnet, die er speichert. Allen Cuba 1960-01-01
Akroyd Christian 1958-12-07
Akroyd Debbie 1990-03-18
Astaire Angelina 1980-03-04
Barrymore Julia 2000-05-16
Akroyd Kirsten 1978-11-02
Allen Cuba 1960-01-01
Allen Kim 1930-07-12
Allen Meryl 1980-12-12
B arrymore Julia 2000-05-16
Basinger Viven 1976-12-08
Basinger Vivien 1979-01-24
Abbildung 3-2: Beispieleinträge aus einem B-Baum-Index (technisch betrachtet einem B+Baum-Index)
106 | Kapitel 3: Schema-Optimierung und Indizierung
Beachten Sie, dass der Index die Werte entsprechend der Reihenfolge der Spalten anordnet, die dem Index in der CREATE TABLE-Anweisung vorgegeben wurde. Schauen Sie sich die beiden letzten Einträge an: Zwei Leute tragen den gleichen Namen, haben aber unterschiedliche Geburtsdaten. Sie wurden nach dem Geburtsdatum sortiert. Arten von Abfragen, die einen B-Baum-Index benutzen können: B-Baum-Indizes funktionieren gut bei Lookups anhand des vollständigen Schlüsselwertes, eines Schlüsselbereichs oder eines Schlüsselpräfixes. Sie sind nur dann sinnvoll, wenn der Lookup mit dem ganz links gelegenen Präfix des Index erfolgt.7 Der Index, den wir im vorherigen Abschnitt gezeigt haben, eignet sich für folgende Abfragearten: Vergleich des vollständigen Wertes Ein Vergleich des vollständigen Schlüsselwertes gibt Werte für alle Spalten in dem Index an. Dieser Index kann Ihnen z.B. helfen, eine Person namens Cuba Allen zu suchen, die am 1. Januar 1960 (1960-01-01) geboren wurde. Vergleich eines ganz links gelegenen Präfixes Dieser Index kann Ihnen helfen, alle Leute mit dem Nachnamen Allen zu finden. Dabei wird nur die erste Spalte im Index benutzt. Vergleich eines Spaltenpräfixes Sie können den ersten Teil eines Spaltenwertes vergleichen. Dieser Index kann Ihnen helfen, alle Leute zu finden, deren Nachnamen mit J beginnen. Dabei wird nur die erste Spalte in dem Index benutzt. Vergleich eines Wertebereichs Dieser Index kann Ihnen helfen, Leute zu finden, deren Nachnamen zwischen Allen und Barrymore liegen. Dabei wird auch nur die erste Spalte benutzt. Ein Teil wird exakt verglichen, bei einem anderen Teil wird ein Bereich verglichen Dieser Index kann Ihnen helfen, alle Leute zu finden, deren Nachname Allen ist und deren Vornamen mit dem Buchstaben K beginnen (Kim, Karl usw.). Dabei handelt es sich um einen exakten Vergleich auf last_name und eine Bereichsabfrage auf first_name. Auf den Index beschränkte Abfragen B-Baum-Indizes können normalerweise Abfragen unterstützen, die auf den Index beschränkt sind. Das sind Abfragen, die nur auf den Index, nicht jedoch auf den Zeilenspeicher zugreifen. Wir besprechen diese Optimierung in »Abdeckende Indizes« auf Seite 128. Da die Knoten des Baums sortiert sind, können sie sowohl für Lookups (zum Auffinden von Werten) als auch für ORDER BY-Abfragen (zum Auffinden von Werten in einer sortierten Reihenfolge) benutzt werden. Falls ein B-Baum Ihnen dabei helfen kann, eine Zeile auf eine bestimmte Weise zu finden, kann er Ihnen im Allgemeinen auch dabei helfen, 7 Das ist MySQL- und sogar versionsspezifisch. Andere Datenbanken können nichtführende Indexteile benutzen, obwohl es normalerweise effizienter ist, ein vollständiges Präfix zu verwenden. Vielleicht bietet MySQL diese Möglichkeit in Zukunft; wir zeigen Ihnen weiter hinten in diesem Kapitel, wie Sie das umgehen.
Grundlagen der Indizierung | 107
Zeilen nach dem gleichen Kriterium zu sortieren. Unser Index ist also auch für ORDER BYKlauseln hilfreich, die alle Arten von Lookups erfassen, die wir gerade aufgeführt haben. Hier sind einige Beschränkungen von B-Baum-Indizes: • Sie sind nicht geeignet, wenn die Suche nicht auf der ganz linken Seite der indizierten Spalten beginnt. So würde Ihnen z.B. dieser Index nicht dabei helfen, alle Leute namens Bill zu finden oder alle Leute, die an einem bestimmten Datum geboren wurden, weil diese Spalten nicht ganz links im Index liegen. Sie können den Index auch nicht dazu benutzen, um Leute zu finden, deren Nachname mit einem bestimmten Buchstaben endet. • Sie können Spalten im Index nicht überspringen. Das heißt, Sie haben keine Möglichkeit, alle Leute zu finden, deren Nachname Smith lautet und die an einem bestimmten Datum geboren wurden. Wenn Sie keinen Wert für die Spalte first_name festlegen, kann MySQL nur die erste Spalte des Index verwenden. • Die Storage-Engine kann Zugriffe mit Spalten rechts der ersten Bereichsbedingung nicht optimieren. Würde z.B. Ihre Abfrage WHERE last_name="Smith" AND first_name LIKE 'J%' AND dob='1976-12-23' lauten, dann würde der Index nur auf die ersten beiden Spalten in dem Index zugreifen, weil LIKE eine Bereichsbedingung ist (der Server kann die anderen Spalten allerdings für andere Zwecke verwenden). Bei einer Spalte, die nur eine begrenzte Anzahl von Werten aufweist, können Sie das oft umgehen, indem Sie Gleichheitsbedingungen anstelle von Bereichsbedingungen festlegen. Wir zeigen weiter hinten in diesem Kapitel in der Indizierungsfallstudie ausführliche Beispiele dafür. Jetzt wissen Sie, wieso wir behauptet haben, dass die Spaltenreihenfolge ausgesprochen wichtig ist: Diese Beschränkungen haben alle mit der Spaltenreihenfolge zu tun. Für Hochleistungsanwendungen müssen Sie möglicherweise Indizes mit den gleichen Spalten in unterschiedlichen Anordnungen herstellen, um Ihre Abfragen zu bedienen. Einige dieser Beschränkungen sind nicht spezifisch für B-Baum-Indizes, sondern sind das Ergebnis dessen, wie der MySQL-Abfrageoptimierer und die Storage-Engines Indizes benutzen. Möglicherweise verschwinden einige von ihnen in Zukunft.
Hash-Indizes Ein Hash-Index wird aus einer Hash-Tabelle erzeugt und eignet sich nur für exakte Lookups, die jede Spalte in dem Index benutzen.8 Für jede Zeile berechnet die StorageEngine einen Hash-Code der indizierten Spalten, bei dem es sich um einen kleinen Wert handelt, der sich wahrscheinlich von den Hash-Codes unterscheidet, die für andere Zeilen mit anderen Schlüsselwerten berechnet wurden. Sie legt die Hash-Codes im Index ab und speichert einen Zeiger auf jede Zeile in einer Hash-Tabelle.
8 In der Informatik-Fachliteratur finden Sie mehr Informationen über Hash-Tabellen.
108 | Kapitel 3: Schema-Optimierung und Indizierung
In MySQL unterstützt nur die Memory-Storage-Engine explizite Hash-Indizes. Diese bilden den Standard-Index-Typ für Memory-Tabellen, obwohl Memory-Tabellen auch B-Baum-Indizes besitzen können. Die Memory-Engine unterstützt uneindeutige HashIndizes, was in der Welt der Datenbanken ungewöhnlich ist. Wenn mehrere Werte denselben Hash-Code aufweisen, speichert der Index ihre Zeilenzeiger im gleichen HashTabelleneintrag mittels einer verknüpften Liste. Hier ist ein Beispiel. Nehmen Sie an, wir haben die folgende Tabelle: CREATE TABLE testhash ( fname VARCHAR(50) NOT NULL, lname VARCHAR(50) NOT NULL, KEY USING HASH(fname) ) ENGINE=MEMORY;
mit diesen Daten: mysql> SELECT * FROM testhash; +--------+-----------+ | fname | lname | +--------+-----------+ | Arjen | Lentz | | Baron | Schwartz | | Peter | Zaitsev | | Vadim | Tkachenko | +--------+-----------+
Nehmen Sie nun noch an, der Index verwendet eine imaginäre Hash-Funktion namens f( ), die folgende Werte zurückliefert (das sind nur Beispiele, keine echten Werte): f('Arjen') f('Baron') f('Peter') f('Vadim')
= = = =
2323 7437 8784 2458
Die Datenstruktur des Index sieht dann so aus: Slot
Wert
2323
Zeiger auf Zeile 1
2458
Zeiger auf Zeile 4
7437
Zeiger auf Zeile 2
8784
Zeiger auf Zeile 3
Beachten Sie, dass die Slots sortiert sind, die Zeilen aber nicht. Wenn wir nun folgende Abfrage durchführen mysql> SELECT lname FROM testhash WHERE fname='Peter';
berechnet MySQL den Hash von 'Peter' und verwendet diesen, um den Zeiger im Index nachzuschlagen. Da f('Peter') = 8784 ist, sucht MySQL im Index nach 8784 und findet den Zeiger auf Zeile 3. Der letzte Schritt besteht darin, den Wert in Zeile 3 mit 'Peter' zu vergleichen, um sicherzustellen, dass dies die richtige Zeile ist.
Grundlagen der Indizierung | 109
Weil die Indizes selbst nur kurze Hash-Werte speichern, sind Hash-Indizes sehr kompakt. Die Länge des Hash-Wertes ist nicht von der Art der Spalten abhängig, die man indiziert – ein Hash-Index eines TINYINT ist genauso groß wie ein Hash-Index einer Spalte mit vielen Zeichen. Aus diesem Grund verlaufen Lookups normalerweise blitzschnell. Allerdings unterliegen Hash-Indizes einigen Einschränkungen: • Da der Index anstelle der Werte selbst nur Hash-Codes und Zeilenzeiger enthält, kann MySQL die Werte in dem Index nicht anstelle der Zeilen lesen. Glücklicherweise ist der Zugriff auf die Zeilen, die sich im Speicher befinden, sehr schnell, so dass die Leistung meist nicht leidet. • MySQL kann Hash-Indizes nicht für die Sortierung benutzen, da die Zeilen nicht in sortierter Reihenfolge gespeichert werden. • Hash-Indizes bieten keine Unterstützung für teilweise Schlüsselvergleiche, da sie den Hash aus dem gesamten indizierten Wert berechnen. Das heißt: Wenn Sie einen Index von (A,B) haben und die WHERE-Klausel Ihrer Abfrage sich nur auf A bezieht, hilft Ihnen der Index nicht weiter. • Hash-Indizes unterstützen nur Gleichheitsvergleiche mit den Operatoren =, IN( ) und <=> (beachten Sie, dass die Operatoren <> und <=> nicht identisch sind). Sie können Bereichsabfragen, wie etwa WHERE preis > 100 nicht beschleunigen. • Der Zugriff auf die Daten in einem Hash-Index ist sehr schnell, es sei denn, es gibt viele Kollisionen (mehrere Werte mit dem gleichen Hash). Wenn es Kollisionen gibt, muss die Storage-Engine jedem Zeilenzeiger in der verknüpften Liste folgen und seinen Wert mit dem Lookup-Wert vergleichen, um die richtige(n) Zeile(n) zu ermitteln. • Manche Operationen zur Indexpflege können langsam sein, wenn es viele HashKollisionen gibt. Falls Sie z.B. einen Hash-Index aus einer Spalte mit einer sehr niedrigen Selektivität (also mit vielen Hash-Kollisionen) erzeugen und dann eine Zeile aus der Tabelle löschen, kann es sehr aufwendig sein, den Zeiger aus dem Index auf diese Zeile zu finden. Die Storage-Engine muss jede Zeile in der verknüpften Liste dieses Hash-Schlüssels untersuchen, um die Referenz auf die eine Zeile, die Sie gelöscht haben, zu finden und zu entfernen. Aufgrund dieser Beschränkungen sind Hash-Indizes nur in Sonderfällen von Nutzen. Wenn Sie allerdings den Anforderungen der Anwendung entsprechen, können sie die Leistung deutlich steigern. Ein Beispiel sind Data-Warehousing-Anwendungen, bei denen ein klassisches »Stern«-Schema viele Joins in Lookup-Tabellen erfordert. HashIndizes sind genau das, was eine Lookup-Tabelle braucht. Zusätzlich zu den expliziten Hash-Indizes der Memory-Storage-Engine unterstützt die NDB Cluster-Storage-Engine eindeutige Hash-Indizes. Ihre Funktionalität ist spezifisch für die NDB Cluster-Storage-Engine, die wir in diesem Buch nicht behandeln.
110 | Kapitel 3: Schema-Optimierung und Indizierung
Die InnoDB-Storage-Engine besitzt eine besondere Eigenschaft namens adaptive HashIndizes. Wenn InnoDB bemerkt, dass auf einige Indexwerte besonders oft zugegriffen wird, baut es für sie im Speicher auf B-Baum-Indizes einen Hash-Index auf. Dies verleiht seinen B-Baum-Indizes einige Eigenschaften der Hash-Indizes, wie etwa sehr schnelle Hash-Lookups. Das funktioniert völlig automatisch, man kann es nicht kontrollieren oder konfigurieren. Eigene Hash-Indizes aufbauen: Falls Ihre Storage-Engine keine Hash-Indizes unterstützt, können Sie sie emulieren, und zwar etwa so wie bei InnoDB. Dadurch haben Sie Zugriff auf einige der wünschenswerten Eigenschaften von Hash-Indizes, z.B. sehr kleine Indexgrößen bei sehr langen Schlüsseln. Die Idee dahinter ist einfach: Sie erzeugen einen Pseudohash-Index auf einem normalen B-Baum-Index. Das ist zwar nicht ganz identisch mit einem echten Hash-Index, weil für Lookups immer noch der B-Baum-Index benutzt wird. Allerdings werden für die Lookups die Hash-Werte der Schlüssel verwendet und nicht die Schlüssel selbst. Sie müssen nur manuell die Hash-Funktion in der WHERE-Klausel der Abfrage angeben. Dieser Ansatz funktioniert z.B. gut für URL-Lookups. URLs sorgen aufgrund ihrer großen Länge im Allgemeinen dafür, dass B-Baum-Indizes riesig werden. Normalerweise würden Sie eine Tabelle mit URLs so abfragen: mysql> SELECT id FROM url WHERE url="http://www.mysql.com";
Falls Sie allerdings den Index der url-Spalte entfernen und der Tabelle eine indizierte url_crc-Spalte hinzufügen, können Sie eine solche Abfrage einsetzen: mysql> SELECT id FROM url WHERE url="http://www.mysql.com" -> AND url_crc=CRC32("http://www.mysql.com");
Das funktioniert, weil der MySQL-Abfrageoptimierer bemerkt, dass es einen kleinen, ausgesprochen selektiven Index in der Spalte url_crc gibt, und einen Index-Lookup für Einträge mit diesem Wert (1560514994, in diesem Fall) durchführt. Selbst wenn mehrere Zeilen den gleichen url_crc-Wert besitzen, ist es sehr einfach, diese Zeilen mit einem schnellen Integer-Vergleich zu ermitteln und zu untersuchen, um die Zeile zu finden, die exakt der vollständigen URL entspricht. Die Alternative besteht darin, die komplette URL als String zu indizieren, was viel langsamer ist. Ein Nachteil dieses Ansatzes ist die Notwendigkeit, die Hash-Werte zu pflegen. Sie können dies manuell erledigen oder seit MySQL 5.0 Trigger einsetzen. Das folgende Beispiel zeigt, wie Trigger die Pflege der url_crc-Spalte beim Einsetzen und Aktualisieren von Werten unterstützen. Zuerst legen wir die Tabelle an: CREATE TABLE pseudohash ( id int unsigned NOT NULL auto_increment, url varchar(255) NOT NULL, url_crc int unsigned NOT NULL DEFAULT 0, PRIMARY KEY(id) );
Grundlagen der Indizierung | 111
Jetzt erzeugen wir die Trigger. Wir ändern zeitweise das Trennzeichen für die Anweisungen, damit wir als Trennzeichen für den Trigger ein Semikolon benutzen können: DELIMITER | CREATE TRIGGER pseudohash_crc_ins BEFORE INSERT ON pseudohash FOR EACH ROW BEGIN SET NEW.url_crc=crc32(NEW.url); END; | CREATE TRIGGER pseudohash_crc_upd BEFORE UPDATE ON pseudohash FOR EACH ROW BEGIN SET NEW.url_crc=crc32(NEW.url); END; | DELIMITER ;
Jetzt müssen wir uns nur noch vergewissern, dass der Trigger den Hash pflegt: mysql> INSERT INTO pseudohash (url) VALUES ('http://www.mysql.com'); mysql> SELECT * FROM pseudohash; +----+----------------------+------------+ | id | url | url_crc | +----+----------------------+------------+ | 1 | http://www.mysql.com | 1560514994 | +----+----------------------+------------+ mysql> UPDATE pseudohash SET url='http://www.mysql.com/' WHERE id=1; mysql> SELECT * FROM pseudohash; +----+-----------------------+------------+ | id | url | url_crc | +----+-----------------------+------------+ | 1 | http://www.mysql.com/ | 1558250469 | +----+-----------------------+------------+
Bei diesem Ansatz sollten Sie keine SHA1( )- oder MD5( )-Hash-Funktionen verwenden. Diese liefern sehr lange Strings zurück, die Platz verschwenden und Vergleiche verlangsamen. Es handelt sich bei ihnen um kryptografisch starke Funktionen, die dazu gedacht sind, Kollisionen virtuell zu eliminieren, was hier aber nicht unser Ziel ist. Einfache Hash-Funktionen können eine bessere Leistung bei akzeptablen Kollisionsraten bieten. Besitzt Ihre Tabelle viele Zeilen und verursacht CRC32( ) zu viele Kollisionen, dann implementieren Sie doch Ihre eigene 64-Bit-Hash-Funktion. Achten Sie darauf, dass die Funktion einen Integer und keinen String zurückliefert. Zum Implementieren einer 64-BitHash-Funktion könnten Sie z.B. nur einen Teil des Wertes verwenden, der von MD5( ) zurückgeliefert wird. Das ist wahrscheinlich nicht so effizient, als wenn Sie Ihre eigene Routine als benutzerdefinierte Funktion schreiben (siehe »Benutzerdefinierte Funktionen« auf Seite 248), geht aber auch: mysql> SELECT CONV(RIGHT(MD5('http://www.mysql.com/'), 16), 16, 10) AS HASH64; +---------------------+ | HASH64 | +---------------------+ | 9761173720318281581 | +---------------------+
112 | Kapitel 3: Schema-Optimierung und Indizierung
Maatkit (http://maatkit.sourceforge.net) enthält eine benutzerdefinierte Funktion, die einen Fowler/Noll/Vo-64-Bit-Hash implementiert, der sehr schnell ist. Mit Hash-Kollisionen zurechtkommen: Wenn Sie einen Wert anhand seines Hashs suchen, müssen Sie auch den eigentlichen Wert in Ihre WHERE-Klausel aufnehmen: mysql> SELECT id FROM url WHERE url_crc=CRC32("http://www.mysql.com") -> AND url="http://www.mysql.com";
Die folgende Abfrage funktioniert nicht richtig, denn wenn eine andere URL den CRC32( )-Wert 1560514994 hat, liefert die Abfrage beide Zeilen zurück: mysql> SELECT id FROM url WHERE url_crc=CRC32("http://www.mysql.com");
Die Wahrscheinlichkeit einer Hash-Kollision wächst aufgrund des sogenannten Geburtstagsparadoxon viel schneller, als man glaubt. CRC32( ) liefert einen 32-Bit-Integer-Wert zurück, so dass die Wahrscheinlichkeit einer Kollision schon bei nur 93.000 Werten bei 1 % liegt. Um das zu verdeutlichen, luden wir alle Wörter aus /usr/share/dict/words zusammen mit ihren CRC32( )-Werten in eine Tabelle, die daraufhin 98.569 Zeilen umfasste. In dieser Datenmenge gibt es bereits eine Kollision! Die Kollision sorgt dafür, dass die folgende Abfrage mehr als eine Zeile zurückliefert: mysql> SELECT word, crc FROM words WHERE crc = CRC32('gnu'); +---------+------------+ | word | crc | +---------+------------+ | codding | 1774765869 | | gnu | 1774765869 | +---------+------------+
Die korrekte Abfrage sieht so aus: mysql> SELECT word, crc FROM words WHERE crc = CRC32('gnu') AND word = 'gnu'; +------+------------+ | word | crc | +------+------------+ | gnu | 1774765869 | +------+------------+
Um Probleme mit Kollisionen zu vermeiden, müssen Sie beide Bedingungen in der WHEREKlausel angeben. Wenn Kollisionen kein Problem darstellen – etwa weil Sie statistische Abfragen durchführen und keine exakten Ergebnisse benötigen –, können Sie sie vereinfachen und eine gewisse Effizienz erreichen, indem Sie nur den CRC32( )-Wert in der WHERE-Klausel verwenden.
Räumliche (R-Baum-)Indizes MyISAM unterstützt räumliche (auch: mehrdimensionale) Indizes, die Sie mit georäumlichen Typen wie GEOMETRY benutzen können. Im Gegensatz zu B-Baum-Indizes verlangen räumliche Indizes nicht, dass Ihre WHERE-Klauseln auf dem ganz links gelegenen Präfix des Index operieren. Sie indizieren die Daten gleichzeitig in allen Dimensionen. Dadurch
Grundlagen der Indizierung | 113
können Lookups effizient eine Kombination der Dimensionen einsetzen. Damit das funktioniert, müssen Sie jedoch die MySQL-GIS-Funktionen verwenden, wie z.B. MBRCONTAINS( ).
Volltextindizes FULLTEXT ist ein besonderer Indextyp für MyISAM-Tabellen. Er sucht Schlüsselwörter im
Text, anstatt Werte direkt mit den Werten im Index zu vergleichen. Die Volltextsuche unterscheidet sich völlig von anderen Arten von Vergleichen. Sie verfügt über viele Feinheiten, wie Stoppwörter, Wortstämme und Pluralformen sowie Boolesche Suchen. Das ist eher analog zu dem, was eine Suchmaschine tut, als zu simplen WHERE-Parametervergleichen. Das Vorhandensein eines Volltextindex in einer Spalte mindert nicht den Wert eines B-Baum-Index in der gleichen Spalte. Volltextindizes sind für MATCH AGAINST-Operationen gedacht, nicht für ordinäre WHERE-Klauseloperationen. Wir besprechen die Volltextindizierung in »Volltextsuche« auf Seite 263 näher.
Indizierungsstrategien für High Performance Um eine gute Abfrageleistung zu erreichen, ist es wesentlich, dass man korrekte Indizes erzeugt und sie richtig anwendet. Wir haben die verschiedenen Arten von Indizes vorgestellt und ihre Stärken und Schwächen erkundet. Jetzt wollen wir einmal schauen, wie man die Stärke von Indizes wirklich ausnutzen kann. Es gibt viele Möglichkeiten, Indizes auszuwählen und effektiv zu benutzen, weil es viele Optimierungen für Spezialfälle und spezialisierte Verhaltensweisen gibt. Mit der Zeit werden Sie lernen, was Sie wann benutzen sollten und wie Sie die Folgen Ihrer Wahl auf die Leistungsfähigkeit zu bewerten haben. Die folgenden Abschnitte helfen Ihnen dabei, zu verstehen, wie Sie Indizes effektiv einsetzen. Vergessen Sie allerdings nicht, Benchmark-Tests durchzuführen!
Die Spalte isolieren MySQL kann im Allgemeinen nur dann Indizes aus Spalten erzeugen, wenn die Spalten in der Abfrage isoliert werden. »Isolieren« der Spalte bedeutet, dass diese nicht Teil eines Ausdrucks sein oder sich innerhalb einer Funktion in der Abfrage befinden sollte. Hier ist z.B. eine Abfrage, die den Index auf actor_id nicht benutzen kann: mysql> SELECT actor_id FROM sakila.actor WHERE actor_id + 1 = 5;
Ein Mensch kann leicht erkennen, dass die WHERE-Klausel äquivalent zu actor_id = 4 ist, MySQL dagegen kann die Gleichung für actor_id nicht lösen. Das müssen Sie erledigen. Sie müssen sich angewöhnen, Ihre WHERE-Kriterien zu vereinfachen, damit die indizierte Spalte allein auf einer Seite des Vergleichsoperators bleibt.
114 | Kapitel 3: Schema-Optimierung und Indizierung
Hier ist ein weiteres Beispiel für einen verbreiteten Fehler: mysql> SELECT ... WHERE TO_DAYS(CURRENT_DATE) - TO_DAYS(date_col) <= 10;
Diese Abfrage sucht alle Zeilen, bei denen der Wert date_col jünger als 10 Tage ist, benutzt aufgrund der Funktion TO_DAYS( ) aber keine Indizes. So formulieren Sie diese Abfrage besser: mysql> SELECT ... WHERE date_col >= DATE_SUB(CURRENT_DATE, INTERVAL 10 DAY);
Diese Abfrage kann problemlos einen Index verwenden, bietet aber noch Raum für Verbesserungen. Der Verweis auf CURRENT_DATE verhindert, dass der Abfrage-Cache die Ergebnisse speichert. Sie können CURRENT_DATE durch ein Literal ersetzen, um dieses Problem zu beheben: mysql> SELECT ... WHERE date_col >= DATE_SUB('2008-01-17', INTERVAL 10 DAY);
In Kapitel 5 finden Sie weitere Einzelheiten zum Abfrage-Cache.
Präfixindizes und Index-Selektivität Manchmal muss man sehr lange Zeichenspalten indizieren, was die Indizes groß und schwerfällig macht. Eine Strategie besteht darin, einen Hash-Index zu simulieren, wie wir bereits weiter vorn in diesem Kapitel gezeigt haben. Manchmal ist das aber nicht gut genug. Was tun? Oft spart man Platz und erzielt eine gute Leistung, wenn man nur die ersten Zeichen anstelle des ganzen Wertes indiziert. Die Indizes benötigen dann weniger Platz, sie sind aber auch weniger selektiv. Indexselektivität bezeichnet das Verhältnis aus der Anzahl der verschiedenen indizierten Werte (Kardinalität) und der Gesamtanzahl der Zeilen in der Tabelle (#T) und reicht von 1/#T bis 1. Ein stark selektiver Index ist gut, weil er MySQL bei seiner Suche nach Treffern bereits mehr Zeilen ausfiltern lässt. Ein eindeutiger Index hat eine Selektivität von 1, besser geht es nicht. Ein Präfix für die Spalte bietet häufig eine ausreichende Selektivität für eine gute Leistung. Wenn Sie BLOB- oder TEXT-Spalten oder sehr lange VARCHAR-Spalten indizieren, dann müssen Sie Präfixindizes definieren, weil MySQL es nicht erlaubt, die vollständige Länge dieser Spalten zu indizieren. Der Trick besteht darin, ein Präfix zu wählen, das lang genug ist, um eine gute Selektivität zu gewährleisten, aber kurz genug, um Platz zu sparen. Das Präfix muss so lang sein, dass der Index fast so nützlich ist, als hätte man die ganze Spalte indiziert. Die Kardinalität des Präfix soll mit anderen Worten fast der Kardinalität der kompletten Spalte entsprechen. Um eine gute Präfixlänge festzulegen, suchen Sie die am häufigsten auftretenden Werte und vergleichen sie mit einer Liste der am häufigsten auftretenden Präfixe. Es gibt keine gute Tabelle, um das in der Sakila-Beispieldatenbank zu demonstrieren, weshalb wir eine aus der city-Tabelle ableiten, damit wir genügend Daten zum Arbeiten haben:
Indizierungsstrategien für High Performance | 115
CREATE TABLE sakila.city_demo(city VARCHAR(50) NOT NULL); INSERT INTO sakila.city_demo(city) SELECT city FROM sakila.city; -- Repeat the next statement five times: INSERT INTO sakila.city_demo(city) SELECT city FROM sakila.city_demo; -- Now randomize the distribution (inefficiently but conveniently): UPDATE sakila.city_demo SET city = (SELECT city FROM sakila.city ORDER BY RAND( ) LIMIT 1);
Jetzt haben wir einen Beispieldatensatz. Die Ergebnisse sind nicht realistisch verteilt, außerdem benutzen wir RAND( ), so dass Ihre Ergebnisse anders aussehen werden, aber das spielt bei dieser Übung keine Rolle. Zuerst suchen wir die am häufigsten auftretenden Städte: mysql> SELECT COUNT(*) AS cnt, city -> FROM sakila.city_demo GROUP BY city ORDER BY cnt DESC LIMIT 10; +-----+----------------+ | cnt | city | +-----+----------------+ | 65 | London | | 49 | Hiroshima | | 48 | Teboksary | | 48 | Pak Kret | | 48 | Yaound | | 47 | Tel Aviv-Jaffa | | 47 | Shimoga | | 45 | Cabuyao | | 45 | Callao | | 45 | Bislig | +-----+----------------+
Sie sehen, dass jeder Wert ungefähr 45- bis 65-mal auftritt. Jetzt suchen wir die am häufigsten auftretenden Stadtnamenpräfixe. Wir beginnen hierbei mit dreibuchstabigen Präfixen: mysql> SELECT COUNT(*) AS cnt, LEFT(city, 3) AS pref -> FROM sakila.city_demo GROUP BY pref ORDER BY cnt DESC LIMIT 10; +-----+------+ | cnt | pref | +-----+------+ | 483 | San | | 195 | Cha | | 177 | Tan | | 167 | Sou | | 163 | al- | | 163 | Sal | | 146 | Shi | | 136 | Hal | | 130 | Val | | 129 | Bat | +-----+------+
Die einzelnen Präfixe tauchen viel häufiger auf, so dass es viel weniger eindeutige Präfixe als eindeutige Städtenamen vollständiger Länge gibt. Der Grundgedanke besteht darin, dass die Präfixlänge erhöht werden soll, bis das Präfix fast so selektiv ist wie die vollständige Länge der Spalte. Ein wenig Herumprobieren ergibt, dass 7 ein guter Wert ist: 116 | Kapitel 3: Schema-Optimierung und Indizierung
mysql> SELECT COUNT(*) AS cnt, LEFT(city, 7) AS pref -> FROM sakila.city_demo GROUP BY pref ORDER BY cnt DESC LIMIT 10; +-----+---------+ | cnt | pref | +-----+---------+ | 70 | Santiag | | 68 | San Fel | | 65 | London | | 61 | Valle d | | 49 | Hiroshi | | 48 | Teboksa | | 48 | Pak Kre | | 48 | Yaound | | 47 | Tel Avi | | 47 | Shimoga | +-----+---------+
Eine weitere Möglichkeit zum Berechnen einer guten Präfixlänge besteht darin, die Selektivität der vollständigen Spalte zu berechnen und zu versuchen, die Selektivität des Präfix an diesen Wert anzunähern. So ermitteln Sie die Selektivität der kompletten Spalte: mysql> SELECT COUNT(DISTINCT city)/COUNT(*) FROM sakila.city_demo; +-------------------------------+ | COUNT(DISTINCT city)/COUNT(*) | +-------------------------------+ | 0.0312 | +-------------------------------+
Das Präfix wird im Durchschnitt ungefähr so gut, wenn wir eine Selektivität nahe .031 anstreben. Es ist möglich, viele verschiedene Längen in einer Abfrage zu bewerten, was sich bei sehr großen Tabellen als sinnvoll erweist. So ermittelt man die Selektivität mehrerer Präfixlängen in einer Abfrage: mysql> SELECT COUNT(DISTINCT LEFT(city, 3))/COUNT(*) AS sel3, -> COUNT(DISTINCT LEFT(city, 4))/COUNT(*) AS sel4, -> COUNT(DISTINCT LEFT(city, 5))/COUNT(*) AS sel5, -> COUNT(DISTINCT LEFT(city, 6))/COUNT(*) AS sel6, -> COUNT(DISTINCT LEFT(city, 7))/COUNT(*) AS sel7 -> FROM sakila.city_demo; +--------+--------+--------+--------+--------+ | sel3 | sel4 | sel5 | sel6 | sel7 | +--------+--------+--------+--------+--------+ | 0.0239 | 0.0293 | 0.0305 | 0.0309 | 0.0310 | +--------+--------+--------+--------+--------+
Diese Abfrage zeigt, dass bei Zunahme der Präfixlängen bis hin zu sieben Zeichen die Verbesserungen schrittweise immer kleiner werden. Es reicht nicht, sich nur die durchschnittliche Selektivität anzuschauen. Sie müssen auch über die Worst-Case-Selektivität denken. Die durchschnittliche Selektivität macht Sie vielleicht glauben, dass ein Präfix mit vier oder fünf Zeichen gut genug ist, aber wenn Ihre Daten sehr ungleichmäßig sind, könnte sich das als Falle herausstellen. Wenn Sie sich die Anzahl der Vorkommen der verbreitetsten Präfixe von Städtenamen mit dem Wert 4 anschauen, dann springt die Ungleichmäßigkeit förmlich ins Auge: Indizierungsstrategien für High Performance | 117
mysql> SELECT COUNT(*) AS cnt, LEFT(city, 4) AS pref -> FROM sakila.city_demo GROUP BY pref ORDER BY cnt DESC LIMIT 5; +-----+------+ | cnt | pref | +-----+------+ | 205 | San | | 200 | Sant | | 135 | Sout | | 104 | Chan | | 91 | Toul | +-----+------+
Bei vier Zeichen treten die häufigsten Präfixe etwas öfter auf als die häufigsten Werte voller Länge. Das bedeutet, dass die Selektivität mit diesen Werten niedriger ist als die durchschnittliche Selektivität. Wenn Sie einen realistischeren Datensatz haben als dieses zufällig erzeugte Beispiel, wird dieser Effekt wahrscheinlich noch offensichtlicher. So würde etwa der Aufbau eines Index aus echten Städtenamen mit Vier-Zeichen-Präfixen eine ungeheuerliche Selektivität bei Städten ergeben, die mit »San« und »New« beginnen, da es von ihnen so viele gibt. Nachdem wir einen guten Wert für unsere Beispieldaten gefunden haben, erfahren Sie nun, wie man einen Präfixindex aus der Spalte erzeugt: mysql> ALTER TABLE sakila.city_demo ADD KEY (city(7));
Mit Präfixindizes können Indizes kleiner und schneller werden, sie bringen aber auch Nachteile mit sich: MySQL kann Präfixindizes nicht für ORDER BY- oder GROUP BY-Abfragen verwenden noch kann es sie als abdeckende Indizes (Covering Index) einsetzen. Manchmal sind Suffixindizes sinnvoll (z.B. zum Ermitteln aller E-MailAdressen einer bestimmten Domain). MySQL unterstützt von sich aus keine umgekehrten Indizes, allerdings können Sie einen umgekehrten String speichern und ein Präfix davon indizieren. Sie pflegen den Index dann z.B. mit Triggern; siehe »Eigene Hash-Indizes aufbauen« auf Seite 111 weiter vorn in diesem Kapitel.
Cluster-Indizes Cluster-Indizes9 bilden keine eigene Art von Indizes, sondern stellen einen Ansatz zur Datenspeicherung dar. Die genauen Einzelheiten variieren zwischen den Implementierungen. Die Cluster-Indizes von InnoDB speichern allerdings tatsächlich einen B-BaumIndex und die Zeilen zusammen in der gleichen Struktur. Wenn eine Tabelle einen Cluster-Index besitzt, werden ihre Zeilen eigentlich in den Blattseiten des Index gespeichert. Der Begriff »Cluster« bezieht sich auf die Tatsache, dass Zeilen mit aufeinanderfolgenden Schlüsselwerten dicht nebeneinander gespeichert
9 Oracle-Benutzern ist der Begriff »indexorganisierte Tabelle« vertraut, der das Gleiche bedeutet.
118 | Kapitel 3: Schema-Optimierung und Indizierung
werden.10 Pro Tabelle kann es nur einen Cluster-Index geben, da es nicht möglich ist, die Zeilen an zwei Stellen auf einmal zu speichern. (Allerdings können Sie mit abdeckenden Indizes mehrere Cluster-Indizes emulieren; mehr dazu später.) Da die Storage-Engines für das Implementieren der Indizes verantwortlich sind, werden sie nicht von allen Storage-Engines unterstützt. Momentan sind solidDB und InnoDB die einzigen, die es tun. Wir konzentrieren uns in diesem Abschnitt auf InnoDB; die Prinzipien, die wir diskutieren, werden aber wahrscheinlich zumindest teilweise für alle Storage-Engines gelten, die Cluster-Indizes jetzt oder in Zukunft unterstützen. Abbildung 3-3 zeigt, wie die Datensätze in einem Cluster-Index angeordnet sind. Wie Sie sehen, enthalten die Blattseiten vollständige Zeilen, die Knotenseiten dagegen nur die indizierten Spalten. In diesem Fall enthält die indizierte Spalte Integer-Werte. 11
1
2
10
Akroyd Christian 1958-12-07
Akroyd Debbie 1990-03-18
Akroyd Kirsten 1978-11-02
21
91
11
12
20
Allen Cuba 1960-01-01
Allen Kim 1930-07-12
Allen Meryl 1980-12-12
91
92
100
Barrymore Julia 2000-05-16
Basinger Vivien 1976-12-08
Basinger Viven 1979-01-24
Abbildung 3-3: Layout von Indexdaten, die in Clustern zusammengefasst sind
Einige Datenbankserver erlauben es Ihnen auszuwählen, welcher Index »geclustert« werden soll, bei den MySQL-Storage-Engines ist das momentan allerdings nicht der Fall. InnoDB packt die Daten anhand des Primärschlüssels in Clustern zusammen. Das bedeutet, dass die »indizierte Spalte« in Abbildung 3-3 die Primärschlüsselspalte ist.
10 Das stimmt nicht immer, wie Sie gleich sehen werden.
Indizierungsstrategien für High Performance | 119
Falls Sie keinen Primärschlüssel definieren, versucht InnoDB stattdessen, einen eindeutigen non-nullable Index zu verwenden. Wenn es keinen solchen Index gibt, definiert InnoDB einen verborgenen Primärschlüssel für Sie und erzeugt die Cluster daraus.11 InnoDB fasst nur Datensätze innerhalb einer Seite zusammen. Zwischen Seiten mit aufeinanderfolgenden Schlüsselwerten kann es einen Abstand geben. Ein zu einem Cluster zusammengepackter Primärschlüssel kann die Leistung verbessern, aber auch zu ernsthaften Leistungsproblemen führen. Sie sollten daher ernsthaft darüber nachdenken, ob Sie mit einem Cluster-Index arbeiten wollen, vor allem, wenn Sie die Storage-Engine einer Tabelle von InnoDB in etwas anderes ändern oder umgekehrt. Das Zusammenpacken von Daten zu Clustern bringt einige wichtige Vorteile mit sich: • Sie können zusammengehörende Daten zusammenhalten. Wenn Sie z.B. eine Mailbox implementieren, dann erzeugen Sie den Cluster anhand von user_id. Auf diese Weise beziehen Sie alle Nachrichten eines Benutzers, indem Sie nur einige Seiten von der Festplatte holen. Ohne Cluster erfordert jede Nachricht ihren eigenen Festplattenzugriff. • Der Datenzugriff erfolgt schnell. Ein Cluster-Index enthält sowohl den Index als auch die Daten zusammen in einem B-Baum, so dass das Beziehen von Zeilen aus einem Cluster-Index normalerweise schneller geht als ein vergleichbarer Lookup in einem Index ohne Cluster. • Abfragen, die abdeckende Indizes verwenden, können die Primärschlüsselwerte benutzen, die im Blattknoten enthalten sind. Diese Vorteile können die Leistung deutlich ankurbeln, wenn Sie Ihre Tabellen und Abfragen so gestalten, dass sie sie ausnutzen. Cluster-Indizes haben aber auch Nachteile: • Das Anlegen von Clustern bringt die größte Verbesserung für ein-/ausgabegebundene Operationen. Wenn die Daten in den Speicher passen, dann spielt die Reihenfolge, in der auf sie zugegriffen wird, eigentlich keine Rolle, und Cluster sind kaum sinnvoll. • Die Einfügegeschwindigkeiten hängen stark von der Einfügereihenfolge ab. Das Einfügen von Zeilen in der Reihenfolge der Primärschlüssel bildet die schnellste Möglichkeit, um Daten in eine InnoDB-Tabelle zu laden. Es könnte ganz günstig sein, die Tabelle nach dem Laden vieler Daten mit OPTIMIZE TABLE neu zu organisieren, wenn die Zeilen nicht in der Primärschlüsselreihenfolge geladen wurden. • Das Aktualisieren der Spalten in einem Cluster-Index ist sehr aufwendig, da InnoDB dabei gezwungen wird, jede aktualisierte Zeile an eine neue Stelle zu verschieben. • Tabellen, die auf Cluster-Indizes aufbauen, neigen zu Seitenaufteilungen, wenn neue Zeilen eingefügt werden oder wenn die Aktualisierung des Primärschlüssels einer Zeile dazu führt, dass die Zeile verschoben werden muss. Zu einer Seitenaufteilung kommt es, wenn der Schlüsselwert einer Zeile vorschreibt, dass die Zeile auf eine 11 Die solidDB-Storage-Engine macht das auch.
120 | Kapitel 3: Schema-Optimierung und Indizierung
Seite platziert werden muss, die bereits voller Daten ist. Die Storage-Engine muss die Seite in zwei Seiten aufteilen, um die Zeile unterzubringen. Seitenaufteilungen können dazu führen, dass eine Tabelle mehr Platz auf der Festplatte erfordert. • Cluster-Tabellen können bei vollständigen Tabellenscans viel langsamer sein, vor allem, wenn Zeilen weniger dicht gepackt sind oder aufgrund von Seitenaufteilungen nicht sequenziell gespeichert werden. • Sekundäre (nonclustered) Indizes können größer werden, als man vermuten würde, da ihre Blattknoten die Primärschlüsselspalten der referenzierten Zeilen enthalten. • Zugriffe auf den sekundären Index erfordern zwei Index-Lookups statt nur einem. Der letzte Punkt kann etwas verwirrend sein. Weshalb sollte ein sekundärer Index zwei Index-Lookups verlangen? Die Antwort liegt in der Natur der »Zeilenzeiger« begründet, die der sekundäre Index speichert. Erinnern Sie sich, ein Blattknoten speichert nicht den Zeiger auf den physischen Ort der referenzierten Zeile, sondern die Primärschlüsselwerte der Zeile. Das heißt, um eine Zeile aus einem sekundären Index zu finden, sucht die StorageEngine zuerst den Blattknoten in dem sekundären Index und verwendet dann die Primärschlüsselwerte, die dort gespeichert sind, um zu dem Primärschlüssel zu gelangen und die Zeile zu finden. Das bedeutet doppelten Aufwand: zwei B-Baum-Navigationen anstelle einer. (In InnoDB kann der adaptive Hash-Index dabei helfen, dieses Handicap zu verringern.)
Vergleich des Datenlayouts von InnoDB und MyISAM Die Unterschiede zwischen Datenlayouts mit und ohne Cluster und die entsprechenden Unterschiede zwischen primären und sekundären Indizes können verwirrend und überraschend sein. Schauen wir uns an, wie InnoDB und MyISAM die folgende Tabelle gestalten: CREATE TABLE layout_test ( col1 int NOT NULL, col2 int NOT NULL, PRIMARY KEY(col1), KEY(col2) );
Nehmen Sie an, in der Tabelle stehen die Primärschlüsselwerte 1 bis 10.000, eingefügt in zufälliger Reihenfolge und dann optimiert mit OPTIMIZE TABLE. Mit anderen Worten: Die Daten sind auf der Festplatte optimal angeordnet, die Zeilen können aber in zufälliger Reihenfolge vorliegen. Die Werte für col2 sind zufällig zwischen 1 und 100 zugewiesen, so dass es viele Duplikate gibt. Das Datenlayout von MyISAM: Das Datenlayout von MyISAM ist einfacher, weshalb wir dies zuerst darstellen. MyISAM speichert die Zeilen auf der Festplatte in der Reihenfolge, in der sie eingefügt wurden, wie in Abbildung 3-4 zu sehen ist.
Indizierungsstrategien für High Performance | 121
Zeilennummer Spalte1 Spalte2 0 99 8 1 12 56 2 3000 62
9997
18
8
9998 9999
4700 3
13 93
Abbildung 3-4: Das MyISAM-Datenlayout für die Tabelle layout_test
Neben den Zeilen stehen die Zeilennummern, beginnend bei 0. Da die Zeilen eine feste Größe besitzen, kann MyISAM eine beliebige Zeile finden, indem es die erforderliche Anzahl an Bytes vom Anfang der Tabelle durchsucht. (MyISAM setzt nicht immer »Zeilennummern« ein, wie wir hier gezeigt haben, es benutzt unterschiedliche Strategien, je nachdem, ob die Zeilen eine feste Größe oder eine variable Größe haben.) Dieses Layout vereinfacht den Aufbau eines Index. Wir verdeutlichen dies hier anhand einer Reihe von Diagrammen, bei denen physische Einzelheiten wie Seiten außer Acht gelassen wurden und nur »Knoten« im Index gezeigt werden. Jeder Blattknoten im Index kann einfach die Zeilennummer enthalten. In Abbildung 3-5 sehen Sie den Primärschlüssel der Tabelle. Spaltenwert Zeilennummer
Interne Knoten
3
99
4700
9999
0
9998
Blattknoten in Spalte1-Anordnung
Abbildung 3-5: MyISAM-Primärschlüssellayout für die Tabelle layout_test
Einige der Details haben wir weggelassen, etwa, wie viele interne B-Baum-Knoten von dem vorhergehenden abstammen, aber das ist auch nicht wichtig, um das grundlegende Datenlayout einer Nicht-Cluster-Storage-Engine zu verstehen. Was ist mit dem Index in col2? Ist damit etwas Besonderes? Wie es aussieht, nicht – es ist einfach ein Index wie jeder andere auch. Abbildung 3-6 zeigt den Index von col2.
122 | Kapitel 3: Schema-Optimierung und Indizierung
Spaltenwert Zeilennummer
Interne Knoten
8
8
13
0
9997
9998
Blattknoten in Spalte2-Anordnung
Abbildung 3-6: MyISAM-Indexlayout von col2 für die Tabelle layout_test
In der Tat gibt es in MyISAM keinen strukturellen Unterschied zwischen einem Primärschlüssel und einem anderen Index. Ein Primärschlüssel ist einfach ein eindeutiger, nonnullable Index namens PRIMARY. Das Datenlayout von InnoDB: InnoDB speichert die gleichen Daten aufgrund seiner Clusterbezogenen Organisation ganz anders. Eine Darstellung der Speicherung sehen Sie in Abbildung 3-7. Primärschlüsselspalten (Spalte1) TID RP
Transaktions-ID Rollback-Zeiger Nichtprimärschlüsselspalten (Spalte2)
Interne Knoten
3
99
4700
TID
TID RP 8
TID RP 13
RP 93
InnoDB-ClusterIndexblattknoten
Abbildung 3-7: Das Primärschlüssellayout von InnoDB für die Tabelle layout_test
Auf den ersten Blick scheint sich das nicht sehr von Abbildung 3-5 zu unterscheiden. Schauen Sie jedoch noch einmal hin. Sie werden bemerken, dass diese Illustration die ganze Tabelle zeigt, nicht nur den Index. Weil der Cluster-Index in der Tabelle in InnoDB »ist«, gibt es keine getrennte Zeilenspeicherung wie bei MyISAM. Jeder Blattknoten im Cluster-Index enthält den Primärschlüsselwert, die Transaktions-ID und den Rollback-Zeiger, den InnoDB für transaktionsbezogene und MVCC-Zwecke
Indizierungsstrategien für High Performance | 123
verwendet, sowie die restlichen Spalten (in diesem Fall col2). Wenn der Primärschlüssel auf einem Spaltenpräfix liegt, fügt InnoDB den restlichen Spalten den vollständigen Spaltenwert hinzu. Ebenso im Gegensatz zu MyISAM sind sekundäre Indizes in InnoDB ganz anders als Cluster-Indizes. Anstatt »Zeilenzeiger« zu speichern, enthalten die Blattknoten des sekundären Index von InnoDB die Primärschlüsselwerte, die als »Zeiger« auf die Zeilen dienen. Diese Strategie verringert die Arbeit, die erforderlich ist, um die sekundären Indizes zu pflegen, wenn die Zeilen verschoben werden oder wenn eine Datenseite aufgeteilt wird. Durch die Verwendung der Primärschlüsselwerte einer Zeile als Zeiger vergrößert sich der Index, allerdings bedeutet es auch, dass InnoDB eine Zeile verschieben kann, ohne die Zeiger auf diese Zeile aktualisieren zu müssen. Abbildung 3-8 zeigt den col2-Index für die Beispieltabelle. Jeder Blattknoten enthält die indizierten Spalten (in diesem Fall nur col2), gefolgt von den Primärschlüsselwerten (col1). Schlüsselspalten (Spalte2) Primärschlüsselspalten (Spalte1)
Interne Knoten
8
8
13
93
18
99
4700
3
InnoDB-SekundärIndexblattknoten
Abbildung 3-8: Das Sekundärschlüssellayout von InnoDB für die Tabelle layout_test
Diese Diagramme haben die B-Baum-Blattknoten dargestellt, wir haben aber absichtlich die Einzelheiten über Knoten weggelassen, die keine Blattknoten sind. Die InnoDB-BBaum-Knoten, die keine Blattknoten sind, enthalten jeweils die indizierte(n) Spalte(n) sowie einen Zeiger auf den nächsttieferen Knoten (bei dem es sich entweder um einen Nichtblattknoten oder um einen Blattknoten handeln kann). Das gilt für alle Indizes, Cluster-Indizes und sekundäre Indizes. Abbildung 3-9 zeigt in einem abstrakten Diagramm, wie InnoDB und MyISAM die Tabelle aufbauen. Anhand dieser Illustration können Sie leicht erkennen, wie unterschiedlich InnoDB und MyISAM Daten und Indizes speichern. Es macht nichts, falls Sie nicht verstehen, warum und wie sich die Cluster- und die NichtCluster-Speicherung unterscheiden und wieso das so wichtig ist. Das wird im weiteren Verlauf dieses Kapitels und im nächsten Kapitel noch deutlicher werden. Diese Konzepte sind kompliziert, und es dauert eine Weile, bis man sie vollständig verstanden hat.
124 | Kapitel 3: Schema-Optimierung und Indizierung
Primärschlüssel
Primärschlüssel
Sekundärschlüssel
Row
Row
Row
Row
Row
Row
Row
Row
Sekundärschlüssel
+ Key
+ Key
+ Key
+ Key
ols PK c
ols PK c
ols PK c
ols PK c
InnoDB- (Cluster-) Tabellenlayout
MyISAM (Nicht-Cluster-) Tabellenlayout
Abbildung 3-9: Cluster- und Nicht-Cluster-Tabellen nebeneinander
Mit InnoDB Zeilen in Primärschlüsselreihenfolge einfügen Wenn Sie InnoDB verwenden und kein spezielles Clustern benötigen, dann sollten Sie möglicherweise einen Surrogatschlüssel definieren. Das ist ein Primärschlüssel, dessen Wert nicht aus den Daten der Anwendung abgeleitet wird. Am einfachsten geht das normalerweise mit einer AUTO_INCREMENT-Spalte. Dies stellt sicher, dass die Zeilen der Reihe nach eingefügt werden, und bietet eine bessere Leistung für Joins mit Primärschlüsseln. Es ist am besten, wenn Sie zufällig (nichtsequeziell) zu Clustern zusammengepackte Schlüssel vermeiden. Beispielsweise ist die Verwendung von UUID-Werten aus Sicht der Leistung eine schlechte Wahl: Das Einfügen in den Cluster-Index erfolgt zufällig – was ganz schlecht ist –, und Sie erhalten keine sinnvollen Daten-Cluster. Zur Demonstration haben wir zwei Fälle Benchmark-Tests unterzogen. Im ersten Fall wird in eine userinfo-Tabelle eine Zeile mit einer Integer-ID eingefügt: CREATE TABLE userinfo ( id int unsigned NOT NULL AUTO_INCREMENT, name varchar(64) NOT NULL DEFAULT '',
Indizierungsstrategien für High Performance | 125
email varchar(64) NOT NULL DEFAULT '', password varchar(64) NOT NULL DEFAULT '', dob date DEFAULT NULL, address varchar(255) NOT NULL DEFAULT '', city varchar(64) NOT NULL DEFAULT '', state_id tinyint unsigned NOT NULL DEFAULT '0', zip varchar(8) NOT NULL DEFAULT '', country_id smallint unsigned NOT NULL DEFAULT '0', gender ('M','F') NOT NULL DEFAULT 'M', account_type varchar(32) NOT NULL DEFAULT '', verified tinyint NOT NULL DEFAULT '0', allow_mail tinyint unsigned NOT NULL DEFAULT '0', parrent_account int unsigned NOT NULL DEFAULT '0', closest_airport varchar(3) NOT NULL DEFAULT '', PRIMARY KEY (id), UNIQUE KEY email (email), KEY country_id (country_id), KEY state_id (state_id), KEY state_id_2 (state_id,city,address) ) ENGINE=InnoDB
Beachten Sie den automatisch inkrementierenden Integer-Primärschlüssel. Der zweite Fall ist eine Tabelle namens userinfo_uuid. Sie ist mit der Tabelle userinfo identisch, allerdings ist ihr Primärschlüssel eine UUID anstelle eines Integer-Wertes: CREATE TABLE userinfo_uuid ( uuid varchar(36) NOT NULL, ...
Wir haben beide Tabellendesigns mit Benchmarks getestet. Zuerst fügten wir in beide Tabellen auf einem Server mit ausreichend Speicher, um die Indizes aufzunehmen, eine Million Datensätze ein. Anschließend fügten wir drei Millionen Zeilen in dieselben Tabellen ein, wodurch die Indizes größer wurden als der Speicher des Servers. In Tabelle 3-2 werden die Benchmark-Ergebnisse verglichen. Tabelle 3-2: Benchmark-Ergebnisse für das Einfügen von Zeilen in InnoDB-Tabellen Tabelle
Zeilen
Zeit (sek)
Indexgröße (MByte)
userinfo
1.000.000
137
342
userinfo_uuid
1.000.000
180
544
userinfo
3.000.000
1233
1036
userinfo_uuid
3.000.000
4525
1707
Sie sehen, dass es nicht nur länger dauert, die Zeilen mit dem UUID-Primärschlüssel einzufügen, die resultierenden Indizes sind auch etwas größer. Zum Teil liegt das an dem größeren Primärschlüssel, aber andererseits zweifellos auch an Seitenaufteilungen und daraus folgender Fragmentierung. Um herauszufinden, warum das so ist, wollen wir uns anschauen, was im Index geschah, als wir Daten in die erste Tabelle einfügten. Abbildung 3-10 zeigt, wie erst eine Seite gefüllt und das Einfügen dann auf einer zweiten Seite fortgesetzt wird.
126 | Kapitel 3: Schema-Optimierung und Indizierung
Sequenzielles Einfügen in die Seite: jeder neue Datensatz wird nach dem vorhergehenden eingefügt 1
2
3
4
4
5
Wenn die Seite voll ist, wird das Einfügen auf einer neuen Seite fortgesetzt ...
...
300
301
301
5
302
302
Abbildung 3-10: Einfügen aufeinanderfolgender Indexwerte in einen Cluster-Index
Wie Abbildung 3-10 verdeutlicht, speichert InnoDB jeden Datensatz unmittelbar nach dem vorhergehenden, da die Primärschlüsselwerte der Reihe nach geordnet sind. Wenn die Seite ihren maximalen Füllfaktor erreicht (bei InnoDB liegt der anfängliche Füllfaktor bei einer 15/16-Füllung, so dass Platz für spätere Änderungen bleibt), kommt der nächste Datensatz auf eine neue Seite. Sobald die Daten auf diese sequenzielle Weise geladen wurden, sind die Seiten fast vollständig mit Datensätzen gefüllt, die bereits geordnet wurden. Das ist ausgesprochen wünschenswert. Vergleichen Sie das einmal mit dem zweiten Szenario, bei dem die Daten mit dem UUIDCluster-Index in die zweite Tabelle eingefügt wurden (siehe Abbildung 3-11). Einfügen von UUIDs: neue Datensätze können zwischen zuvor eingefügten Datensätzen eingefügt werden, wodurch diese verschoben werden 000944 0016c9 002f21 16-6175 1a-6175 8e-6177
002775 64-6178
000e2f 20-6180
Seiten, die gefüllt und auf die Festplatte übertragen wurden, müssen möglicherweise erneut gelesen werden 000944 000e2f 0016c9 002775 002f21 16-6175 20-6180 1a-6175 64-6178 8e-6177
001475 64-6181 *Es werden nur die ersten 13 Zeichen der UUID gezeigt
Abbildung 3-11: Einfügen von nichtsequeziellen Werten in einen Cluster-Index
Indizierungsstrategien für High Performance | 127
Da eine neue Zeile nicht unbedingt einen größeren Primärschlüsselwert besitzt als die vorhergehende Zeile, kann InnoDB sie nicht immer an das Ende des Index setzen. Es muss die passende Stelle für die Zeile finden – im Durchschnitt irgendwo in der Mitte der vorhandenen Daten – und Platz dafür schaffen. Dies verursacht eine Menge Zusatzaufwand und sorgt für eine suboptimale Anordnung der Daten. Hier ist eine Zusammenfassung der Nachteile: • Die Zielseite könnte auf die Platte geschrieben und aus dem Cache entfernt worden sein. In diesem Fall muss InnoDB sie suchen und erneut von der Festplatte einlesen, bevor es die neue Zeile einfügen kann. Dies verursacht viele zufällige Ein-/Ausgaben. • Manchmal muss InnoDB Seiten aufteilen, um Platz für neue Zeilen zu schaffen. Das erfordert ein Verschieben vieler Daten. • Seiten werden aufgrund der Aufteilungen spärlich und unregelmäßig gefüllt, so dass die fertigen Daten fragmentiert sind. Nach dem Laden solcher willkürlichen Werte in einen Cluster-Index müssen Sie wahrscheinlich erst einmal OPTIMIZE TABLE ausführen, um die Tabelle neu aufzubauen und die Seiten optimal zu füllen. Die Moral von der Geschichte lautet, dass Sie danach streben sollten, die Daten in der Primärschlüsselreihenfolge einzufügen, wenn Sie InnoDB verwenden, und dass Sie versuchen sollten, einen Cluster-fähigen Schlüssel zu benutzen, der Ihnen für jede neue Zeile einen monoton ansteigenden Wert liefert.
Wann die Primärschlüsselreihenfolge nachteilig ist Bei stark nebenläufiger Auslastung kann das Einfügen in Primärschlüsselreihenfolge bei InnoDB, so, wie es momentan implementiert ist, eine Problemstelle schaffen. Dieser »Hotspot« liegt beim oberen Ende des Primärschlüssels. Da alle Einfügungen dort stattfinden, kann es passieren, dass parallel erfolgende Einfügungen einander die Locks für den nächsten Schlüssel und/oder die AUTO_INCREMENT-Locks streitig machen (der Hotspot kann bei einem von ihnen oder bei beiden liegen). Wenn bei Ihnen dieses Problem auftritt, dann könnten Sie Ihre Tabelle oder Anwendung umgestalten oder InnoDB so anpassen, dass es mit dieser speziellen Situation besser zurechtkommt. In Kapitel 6 erfahren Sie mehr über das Anpassen von InnoDB.
Abdeckende Indizes Indizes bieten eine Methode, um Zeilen effizient zu suchen. MySQL kann einen Index aber auch benutzen, um die Daten einer Spalte zu holen, so dass es die Zeile gar nicht lesen muss. Schließlich enthalten die Blattknoten des Index die Werte, die sie indizieren; weshalb sollte man daher die Zeile lesen, wenn das Lesen des Index bereits die gewünschten Daten liefern kann? Ein Index, der alle Daten enthält (oder »abdeckt«), die nötig sind, um eine Abfrage zu beantworten, wird als abdeckender Index (Covering Index) bezeichnet. 128 | Kapitel 3: Schema-Optimierung und Indizierung
Abdeckende Indizes sind ein starkes Werkzeug und können die Leistung deutlich verbessern. Bedenken Sie die Vorteile, die sich ergeben, wenn nur der Index anstelle der Daten gelesen wird: • Indexeinträge sind normalerweise viel kleiner als die vollständige Zeile. MySQL muss also auf deutlich weniger Daten zugreifen, wenn es nur den Index liest. Das ist für im Cache gespeicherte Operationen sehr wichtig, bei denen sich ein Großteil der Antwortzeit durch das Kopieren der Daten ergibt. Auch für ein-/ausgabegebundene Operationen ist das hilfreich, da die Indizes kleiner als die Daten sind und besser in den Speicher passen. (Das gilt vor allem für MyISAM, das Indizes packen kann, so dass sie noch kleiner werden.) • Indizes werden nach ihren Indexwerten sortiert (zumindest innerhalb der Seite), so dass ein-/ausgabegebundene Bereichszugriffe im Vergleich zu Zugriffen, bei denen jede Zeile von einer anderen Stelle auf der Festplatte geholt werden muss, weniger Ein-/Ausgaben benötigen. Bei manchen Storage-Engines, wie etwa MyISAM, können Sie die Tabelle sogar mit OPTIMIZE optimieren, um vollständig sortierte Indizes zu erhalten. Dadurch wären für einfache Bereichsabfragen vollständig sequenzielle Indexzugriffe möglich. • Die meisten Storage-Engines speichern Indizes besser als Daten im Cache. (Falcon bildet eine bemerkenswerte Ausnahme.) Manche Storage-Engines, wie etwa MyISAM, speichern nur den Index im MySQL-Cache. Da das Betriebssystem die Daten für MyISAM im Cache speichert, ist für den Zugriff darauf typischerweise ein Systemaufruf erforderlich. Das hat möglicherweise starke Auswirkungen auf die Leistung, vor allem bei im Cache ablaufenden Operationen, für die der Systemaufruf den teuersten Teil des Datenzugriffs darstellt. • Abdeckende Indizes sind wegen der Cluster-Indizes von InnoDB besonders für InnoDB-Tabellen sinnvoll. Die sekundären Indizes von InnoDB enthalten die Primärschlüsselwerte der Zeile in ihren Blattknoten. Ein sekundärer Index, der eine Abfrage abdeckt, verhindert daher einen weiteren Index-Lookup im Primärschlüssel. In all diesen Szenarien ist es typischerweise deutlich preiswerter, eine Abfrage aus einem Index zu beantworten, als die Zeilen zu durchsuchen. Ein abdeckender Index ist nicht einfach eine beliebige Art von Index. Der Index muss die Werte aus den Spalten speichern, die er enthält. Hash-Indizes, räumliche Indizes und Volltextindizes speichern diese Werte nicht; MySQL kann daher nur B-Baum-Indizes verwenden, um Abfragen abzudecken. Auch abdeckende Indizes werden von den verschiedenen Storage-Engines unterschiedlich implementiert, und nicht alle Storage-Engines unterstützen sie (momentan tun die Memory- und die Falcon-Storage-Engine dies nicht). Wenn Sie eine Abfrage starten, die von einem Index abgedeckt wird (eine index-covered Query), dann steht »Using index« in der Extra-Spalte in EXPLAIN.12 Beispielsweise besitzt 12 Man kann »Using index« in der Extra-Spalte leicht mit »index« in der type-Spalte verwechseln. Sie sind jedoch völlig unterschiedlich. Die type-Spalte hat nichts mit abdeckenden Indizes zu tun; sie zeigt den Zugriffstyp der Abfrage oder wie die Abfrage die Zeilen sucht.
Indizierungsstrategien für High Performance | 129
die Tabelle sakila.inventory einen mehrspaltigen Index in (store_id, film_id). MySQL kann diesen Index für eine Abfrage benutzen, die nur auf diese beiden Spalten zugreift: mysql> EXPLAIN SELECT store_id, film_id FROM sakila.inventory\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: inventory type: index possible_keys: NULL key: idx_store_id_film_id key_len: 3 ref: NULL rows: 4673 Extra: Using index
Indexabdeckende Abfragen enthalten Feinheiten, die diese Optimierung beeinträchtigen können. Der MySQL-Abfrageoptimierer entscheidet vor dem Ausführen einer Abfrage, ob ein Index sie abdeckt. Nehmen Sie an, der Index deckt eine WHERE-Bedingung ab, aber nicht die gesamte Abfrage. Wenn die Bedingung als falsch bewertet wird, holen MySQL 5.1 und frühere Versionen die Zeile dennoch, obwohl sie sie nicht brauchen und herausfiltern. Schauen wir uns an, wie das passieren kann und wie man die Abfrage verändern muss, um das Problem zu umgehen. Wir beginnen mit der folgenden Abfrage: mysql> EXPLAIN SELECT * FROM products WHERE actor='SEAN CARREY' -> AND title like '%APOLLO%'\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: products type: ref possible_keys: ACTOR,IX_PROD_ACTOR key: ACTOR key_len: 52 ref: const rows: 10 Extra: Using where
Der Index kann diese Abfrage aus zwei Gründen nicht abdecken: • Kein Index deckt die Abfrage ab, da wir alle Spalten aus der Tabelle ausgewählt haben und kein Index alle Spalten abdeckt. Theoretisch gibt es eine Abkürzung, die MySQL benutzen könnte, allerdings führt die WHERE-Klausel nur Spalten auf, die der Index abdeckt, MySQL könnte deshalb den Index einsetzen, um den Schauspieler zu finden, dann überprüfen, ob der Titel passt, und nur dann die vollständige Zeile lesen. • MySQL kann die LIKE-Operation im Index nicht ausführen. Das ist eine Einschränkung der Storage-Engine-API, die nur einfache Vergleiche in Indexoperationen erlaubt. MySQL kann präfixvergleichende LIKE-Muster im Index ausführen, weil es sie in einfache Vergleiche umwandeln kann, das führende Wildcard in der Abfrage
130 | Kapitel 3: Schema-Optimierung und Indizierung
verhindert jedoch, dass die Storage-Engine den Vergleich auswertet. Daher muss der MySQL-Server selbst die Werte der Zeile holen und vergleichen und kann dies nicht mit den Werten des Index erledigen. Es gibt eine Kombination aus cleverer Indizierung und Umschreiben der Abfrage, mit der man beide Probleme umgehen kann. Wir können den Index so erweitern, dass er (artist, title, prod_id) abdeckt, und schreiben die Abfrage um: mysql> EXPLAIN SELECT * -> FROM products -> JOIN ( -> SELECT prod_id -> FROM products -> WHERE actor='SEAN CARREY' AND title LIKE '%APOLLO%' -> ) AS t1 ON (t1.prod_id=products.prod_id)\G *************************** 1. row *************************** id: 1 select_type: PRIMARY table: <derived2> ...weggelassen... *************************** 2. row *************************** id: 1 select_type: PRIMARY table: products ...weggelassen... *************************** 3. row *************************** id: 2 select_type: DERIVED table: products type: ref possible_keys: ACTOR,ACTOR_2,IX_PROD_ACTOR key: ACTOR_2 key_len: 52 ref: rows: 11 Extra: Using where; Using index
MySQL verwendet den abdeckenden Index im ersten Stadium der Abfrage, wenn es passende Zeilen in der Unterabfrage der FROM-Klausel sucht. Es deckt mit dem Index nicht die ganze Abfrage ab, aber insgesamt ist es besser als nichts. Die Effektivität dieser Optimierung hängt davon ab, wie viele Zeilen die WHERE-Klausel findet. Nehmen Sie an, die Tabelle products enthält eine Million Zeilen. Wir wollen uns anschauen, wie diese beiden Abfragen mit den drei unterschiedlichen Datenmengen funktionieren, die jeweils eine Million Zeilen enthalten: 1. In der ersten haben 30.000 Produkte Sean Carrey als Schauspieler, und 20.000 von
ihnen enthalten Apollo im Titel. 2. In der zweiten haben 30.000 Produkte Sean Carrey als Schauspieler, und 40 von ihnen enthalten Apollo im Titel. 3. In der dritten haben 50 Produkte Sean Carrey als Schauspieler, und 10 von ihnen enthalten Apollo im Titel.
Indizierungsstrategien für High Performance | 131
Wir verwendeten diese drei Datenmengen für Benchmarks der zwei Variationen der Abfrage und erhielten die Ergebnisse, die in Tabelle 3-3 gezeigt werden. Tabelle 3-3: Benchmark-Ergebnisse für indexabdeckende Abfragen im Vergleich mit nichtindexabdeckenden Abfragen Datenmenge
Originalabfrage
Optimierte Abfrage
Beispiel 1
5 Abfragen pro Sekunde
5 Abfragen pro Sekunde
Beispiel 2
7 Abfragen pro Sekunde
35 Abfragen pro Sekunde
Beispiel 3
2400 Abfragen pro Sekunde
2000 Abfragen pro Sekunde
Und so kann man diese Ergebnisse interpretieren: • In Beispiel 1 liefert die Abfrage eine große Ergebnismenge zurück, so dass die Wirkung der Optimierung nicht zu erkennen ist. Der größte Teil der Zeit wird mit dem Lesen und Senden der Daten verbracht. • Beispiel 2, bei dem der zweite Bedingungsfilter nach der Indexfilterung nur eine kleine Ergebnismenge hinterlässt, zeigt, wie effektiv die vorgeschlagene Optimierung ist: Die Leistung ist mit unseren Daten fünfmal besser. Die Effizienz ergibt sich daraus, dass nur 40 vollständige Zeilen gelesen werden müssen und nicht 30.000 wie in der ersten Abfrage. • Beispiel 3 zeigt den Fall einer ineffizienten Unterabfrage. Die Menge der Ergebnisse, die nach der Indexfilterung bleibt, ist so klein, dass die Unterabfrage teurer ist als das Lesen aller Daten aus der Tabelle. Diese Optimierung ist manchmal eine effektive Methode, um in MySQL 5.1 und früheren Versionen das Lesen unnötiger Zeilen zu vermeiden. MySQL 6.0 kann diese zusätzliche Arbeit selbst umgehen, so dass es Ihnen möglich sein dürfte, Ihre Abfragen zu vereinfachen, wenn Sie auf diese höhere Version umsteigen. Bei den meisten Storage-Engines kann ein Index nur Abfragen abdecken, die auf Spalten zugreifen, die Teil des Index sind. InnoDB dagegen treibt diese Optimierung ein wenig weiter. Erinnern Sie sich daran, dass die sekundären Indizes von InnoDB in ihren Blattknoten Primärschlüsselwerte enthalten. Das bedeutet, dass die sekundären Indizes von InnoDB gewissermaßen »Zusatzspalten« enthalten, die InnoDB benutzen kann, um Abfragen abzudecken. Beispielsweise benutzt die Tabelle sakila.actor InnoDB und hat einen Index in last_name. Der Index kann also Abfragen abdecken, die die Primärschlüsselspalte actor_id beziehen, obwohl diese Spalte technisch gesehen kein Teil des Index ist: mysql> EXPLAIN SELECT actor_id, last_name -> FROM sakila.actor WHERE last_name = 'HOPPER'\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: actor type: ref
132 | Kapitel 3: Schema-Optimierung und Indizierung
possible_keys: key: key_len: ref: rows: Extra:
idx_actor_last_name idx_actor_last_name 137 const 2 Using where; Using index
Indexscans für Sortierungen verwenden MySQL bietet zwei Möglichkeiten, um sortierte Ergebnisse herzustellen: Entweder setzt es ein Filesort ein oder es fragt einen Index in der Reihenfolge ab.13 Man kann feststellen, wann MySQL vorhat, einen Index zu scannen, indem man nach »index« in der typeSpalte in EXPLAIN sucht. (Verwechseln Sie das nicht mit »Using index« in der ExtraSpalte.) Das Scannen des Index selbst geht schnell, weil dabei nur von einem Indexeintrag zum nächsten gegangen werden muss. Falls allerdings MySQL den Index nicht benutzt, um die Abfrage abzudecken, muss es jede Zeile nachschauen, die es im Index findet. Dabei handelt es sich prinzipiell um zufällige Ein-/Ausgaben. Das Lesen der Daten in der Indexreihenfolge ist deshalb normalerweise viel langsamer als ein sequenzieller Tabellenscan, vor allem bei ein-/ausgabegebundenen Operationen. MySQL kann den gleichen Index zum Sortieren und zum Suchen von Zeilen verwenden. Falls möglich, sollten Sie Ihre Indizes so gestalten, dass sie sich gut für beide Aufgaben eignen. Das Anordnen der Ergebnisse nach dem Index funktioniert nur dann, wenn die Reihenfolge des Index exakt die gleiche ist wie die ORDER BY-Klausel und alle Spalten in der gleichen Richtung sortiert sind (aufsteigend oder absteigend). Wenn die Abfrage mehrere Tabellen zusammenführt, funktioniert das nur, wenn alle Spalten in der ORDER BY-Klausel auf die erste Tabelle verweisen. Die ORDER BY-Klausel unterliegt außerdem den gleichen Beschränkungen wie Lookup-Abfragen: Sie muss einen ganz links liegenden Präfix des Index formulieren. In allen anderen Fällen verwendet MySQL ein Filesort. Ein Fall, bei dem die ORDER BY-Klausel kein ganz links liegendes Präfix des Index angeben muss, tritt auf, wenn es Konstanten für die führenden Spalten gibt. Legen die WHERE- oder eine JOIN-Klausel Konstanten für diese Spalten fest, können sie die »Lücken im Index füllen«. Zum Beispiel hat die Tabelle rental in der normalen Sakila-Beispieldatenbank einen Index in (rental_date, inventory_id, customer_id): CREATE TABLE rental ( ... PRIMARY KEY (rental_id), UNIQUE KEY rental_date (rental_date,inventory_id,customer_id),
13 MySQL besitzt zwei Filesort-Mechanismen; Sie erfahren darüber mehr in »Sortieroptimierungen« auf Seite 190.
Indizierungsstrategien für High Performance | 133
KEY idx_fk_inventory_id (inventory_id), KEY idx_fk_customer_id (customer_id), KEY idx_fk_staff_id (staff_id), ... );
MySQL benutzt den rental_date-Index, um die folgende Abfrage zu sortieren, wie Sie am Fehlen eines Filesort in EXPLAIN erkennen: mysql> EXPLAIN SELECT rental_id, staff_id FROM sakila.rental -> WHERE rental_date = '2005-05-25' -> ORDER BY inventory_id, customer_id\G *************************** 1. row *************************** type: ref possible_keys: rental_date key: rental_date rows: 1 Extra: Using where
Das funktioniert, obwohl die ORDER BY-Klausel selbst nicht ein am weitesten links gelegenes Präfix des Index ist, weil wir eine Gleichheitsbedingung für die erste Spalte im Index angegeben haben. Hier sind einige weitere Abfragen, die den Index für die Sortierung benutzen können. Diese hier funktioniert, weil die Abfrage eine Konstante für die erste Spalte des Index liefert und ein ORDER BY in der zweiten Spalte angibt. Zusammengenommen formen diese zwei ein ganz links gelegenes Präfix des Index: ... WHERE rental_date = '2005-05-25' ORDER BY inventory_id DESC;
Die folgende Abfrage funktioniert auch, weil die zwei Spalten in ORDER BY ein ganz links gelegenes Präfix des Index bilden: ... WHERE rental_date > '2005-05-25' ORDER BY rental_date, inventory_id;
Hier sehen Sie einige Abfragen, die den Index nicht für die Sortierung verwenden können: • Diese Abfrage benutzt zwei verschiedene Sortierrichtungen, die Spalten des Index sind jedoch alle aufsteigend sortiert: ... WHERE rental_date = '2005-05-25' ORDER BY inventory_id DESC, customer_id ASC;
• Hier bezieht sich ORDER BY auf eine Spalte, die nicht im Index liegt: ... WHERE rental_date = '2005-05-25' ORDER BY inventory_id, staff_id;
• Hier formen die WHERE- und die ORDER BY-Klausel nicht das am weitesten links gelegene Präfix des Index: ... WHERE rental_date = '2005-05-25' ORDER BY customer_id;
• Diese Abfrage hat eine Bereichsbedingung in der ersten Spalte, so dass MySQL den Rest des Index nicht verwendet: ... WHERE rental_date > '2005-05-25' ORDER BY inventory_id, customer_id;
• Hier gibt es eine mehrfache Gleichheit in der Spalte inventory_id. Für die Zwecke der Sortierung ist das im Prinzip das Gleiche wie ein Bereich: ... WHERE rental_date = '2005-05-25' AND inventory_id IN(1,2) ORDER BY customer_id;
134 | Kapitel 3: Schema-Optimierung und Indizierung
• Hier ist ein Beispiel, bei dem MySQL theoretisch einen Index benutzen könnte, um ein Join zu sortieren. Das tut es aber nicht, weil der Optimierer die Tabelle film_actor als Zweites in den Join setzt (Kapitel 4 zeigt Möglichkeiten, um die JoinReihenfolge zu ändern): mysql> EXPLAIN SELECT actor_id, title FROM sakila.film_actor -> INNER JOIN sakila.film USING(film_id) ORDER BY actor_id\G +------------+----------------------------------------------+ | table | Extra | +------------+----------------------------------------------+ | film | Using index; Using temporary; Using filesort | | film_actor | Using index | +------------+----------------------------------------------+
Eine der wichtigsten Anwendungen für eine Anordnung nach dem Index ist eine Abfrage, die sowohl eine ORDER BY- als auch eine LIMIT-Klausel aufweist. Wir gehen später genauer darauf ein.
Gepackte (Präfixkomprimierte) Indizes MyISAM setzt Präfixkomprimierung ein, um die Indexgröße zu reduzieren, wodurch ein größerer Teil des Index in den Speicher passt und die Leistung sich gelegentlich deutlich verbessert. Stringwerte werden standardmäßig gepackt, Sie können MyISAM jedoch auch anweisen, Integer-Werte zu komprimieren. MyISAM packt die einzelnen Indexblöcke, indem es den ersten Wert des Blocks vollständig speichert. Anschließend speichert es jeden weiteren Wert im Block, indem es die Anzahl der Bytes aufzeichnet, die das gleiche Präfix besitzen, sowie die tatsächlichen Daten des Suffix, das sich von den anderen Suffixen unterscheidet. Falls z.B. der erste Wert »perform« ist und der zweite »performance« lautet, dann wird der zweite Wert analog als »7,ance« gespeichert. MyISAM kann auch benachbarte Zeilenzeiger präfixkomprimieren. Komprimierte Blöcke brauchen weniger Platz, verlangsamen aber auch bestimmte Operationen. Da das Komprimierungspräfix eines Wertes vom Wert davor abhängt, kann MyISAM keine Binärsuchen durchführen, um einen gewünschten Eintrag im Block zu finden, und muss den Block vom Anfang an scannen. Sequenzielle Vorwärtsscans funktionieren gut, umgekehrte Scans dagegen – wie etwa ORDER BY DESC – nicht so gut. Jede Operation, bei der eine einzelne Zeile in der Mitte des Blocks gefunden werden muss, erfordert im Durchschnitt das Scannen des halben Blocks. Unsere Benchmarks haben gezeigt, dass gepackte Schlüssel dafür sorgen, dass IndexLookups in MyISAM-Tabellen bei einer CPU-gebundenen Operation mehrfach langsamer verlaufen, weil die Scans willkürliche Lookups erfordern. Umgekehrte Scans von gepackten Schlüsseln sind sogar noch langsamer. Man muss zwischen CPU- und Speicherressourcen auf der einen und Festplattenressourcen auf der anderen Seite wählen. Gepackte Indizes nehmen nur etwa ein Zehntel des Platzes auf der Festplatte ein, und wenn Sie ein-/ausgabegebundene Operationen haben, dann gleichen sie wahrscheinlich die Kosten für bestimmte Abfragen mehr als aus.
Indizierungsstrategien für High Performance | 135
Mit der CREATE TABLE-Option PACK_KEYS können Sie kontrollieren, wie die Indizes einer Tabelle gepackt sind.
Redundante und duplizierte Indizes MySQL erlaubt es Ihnen, mehrere Indizes in derselben Spalte herzustellen; es erkennt und verhindert diesen Fehler nicht. MySQL muss jeden duplizierten Index gesondert pflegen. Der Abfrageoptimierer berücksichtigt alle Indizes beim Optimieren von Abfragen. Das kann ernsthafte Auswirkungen auf die Leistung haben. Duplizierte Indizes sind Indizes desselben Typs, erzeugt aus dem gleichen Satz Spalten in der gleichen Reihenfolge. Vermeiden Sie es, duplizierte Indizes zu erzeugen, und löschen Sie sie, wenn Sie sie finden. Manchmal merkt man gar nicht, dass man duplizierte Indizes erzeugt. Schauen Sie sich z.B. den folgenden Code an: CREATE TABLE test ( ID INT NOT NULL PRIMARY KEY, UNIQUE(ID), INDEX(ID) );
Ein unerfahrener Benutzer könnte denken, dass dies die Rolle der Spalte als Primärschlüssel kennzeichnet, ein UNIQUE-Constraint hinzufügt und einen Index anlegt, den Abfragen benutzen können. Tatsächlich implementiert MySQL UNIQUE-Constraints und PRIMARY KEY-Constraints bereits mit Indizes, so dass hier in Wirklichkeit drei Indizes in derselben Spalte erzeugt werden! Dazu gibt es normalerweise keinen Grund, es sei denn, Sie wollen drei unterschiedliche Arten von Indizes in derselben Spalte haben, um unterschiedliche Arten von Abfragen zu bedienen.14 Redundante Indizes unterscheiden sich ein wenig von duplizierten Indizes. Wenn es einen Index in (A, B) gibt, dann wäre ein weiterer Index in (A) redundant, weil er ein Präfix des ersten Index wäre. Das heißt, der Index in (A, B) kann auch als Index in (A) allein benutzt werden. (Diese Art von Redundanz gilt nur für B-Baum-Indizes.) Ein Index in (B, A) wäre dagegen nicht redundant, genauso wenig wie ein Index in (B), weil B nicht das am weitesten links gelegene Präfix von (A, B) ist. Außerdem sind Indizes unterschiedlicher Typen (wie etwa Hash- oder Volltextindizes) nicht redundant zu B-Baum-Indizes, egal welche Spalten sie abdecken. Redundante Indizes erscheinen normalerweise, wenn Datenbankverwalter Indizes zu einer Tabelle hinzufügen. Beispielsweise könnte jemand einen Index in (A, B) hinzufügen, anstatt einen vorhandenen Index in (A) so zu erweitern, dass er (A, B) abdeckt.
14 Ein Index ist nicht unbedingt ein Duplikat, wenn er einer anderen Art von Index angehört; oft gibt es gute Gründe für KEY(col) und FULLTEXT KEY(col).
136 | Kapitel 3: Schema-Optimierung und Indizierung
Meist sind redundante Indizes unerwünscht. Um sie zu vermeiden, sollten Sie lieber vorhandene Indizes erweitern, als neue anzulegen. Manchmal allerdings benötigt man aus Leistungsgründen redundante Indizes. Das Erweitern eines vorhandenen Index könnte ihn zu sehr vergrößern und die Leistung bei manchen Abfragen herabsetzen. Falls Sie z.B. einen Index in einer Integer-Spalte haben und ihn mit einer langen VARCHARSpalte erweitern, könnte er deutlich langsamer werden. Das gilt vor allem, wenn Ihre Abfragen den Index als abdeckenden Index benutzen oder wenn es sich um eine MyISAM-Tabelle handelt und Sie viele Bereichsscans darauf durchführen (wegen der Präfixkomprimierung von MyISAM). Denken Sie an die Tabelle userinfo, die wir in »Mit InnoDB Zeilen in Primärschlüsselreihenfolge einfügen« auf Seite 125 beschrieben haben. Diese Tabelle enthält 1.000.000 Zeilen, und für jedes state_id gibt es etwa 20.000 Datensätze. Es gibt einen Index in state_id, der für die folgende Abfrage geeignet ist. Wir bezeichnen diese Abfrage als Q1: mysql> SELECT count(*) FROM userinfo WHERE state_id=5;
Ein einfacher Benchmark zeigt eine Ausführungsrate von fast 115 Abfragen pro Sekunde (Queries per Second; QPS) für diese Abfrage. Wir haben eine verwandte Abfrage, die mehrere Spalten holt, anstatt nur Zeilen zu zählen. Dies ist Q2: mysql> SELECT state_id, city, address FROM userinfo WHERE state_id=5;
Bei dieser Abfrage ist das Ergebnis kleiner als 10 QPS.15 Die einfache Lösung zum Steigern der Leistung besteht darin, den Index auf (state_id, city, address) zu erweitern, so dass er die Abfrage abdeckt: mysql> ALTER TABLE userinfo DROP KEY state_id, -> ADD KEY state_id_2 (state_id, city, address);
Nach dem Erweitern des Index läuft Q2 schneller, Q1 dagegen ist langsamer. Falls wir wirklich daran interessiert sind, dass beide Abfragen schnell ausgeführt werden, sollten wir beide Indizes so lassen, auch wenn der einspaltige Index redundant ist. Tabelle 3-4 zeigt ausführliche Ergebnisse für beide Abfragen und Indizierungsstrategien bei den Storage-Engines MyISAM und InnoDB. Sie können erkennen, dass die Leistung von InnoDB für Q1 mit dem state_id_2-Index nicht so stark abfällt, da InnoDB keine Schlüsselkomprimierung verwendet. Tabelle 3-4: Benchmark-Ergebnisse in QPS für SELECT-Abfragen mit verschiedenen Indizierungsstrategien Nur state_id
Nur state_id_2
Sowohl state_id als auch state_id_2
MyISAM, Q1
114,96
25,40
112,19
MyISAM, Q2
9,97
16,34
16,37
InnoDB, Q1
108,55
100,33
107,97
InnoDB, Q2
12,12
28,04
28,06
15 Wir haben hier ein Beispiel benutzt, das in den Speicher passt. Wenn die Tabelle größer ist und die Operationen viele Ein-/Ausgaben verwenden, wird der Unterschied zwischen diesen Werten noch größer.
Indizierungsstrategien für High Performance | 137
Leider bringen zwei Indizes auch einen erhöhten Wartungsaufwand mit sich. Tabelle 3-5 zeigt, wie lange es dauert, um eine Million Zeilen in die Tabelle einzufügen. Tabelle 3-5: Benötigte Zeit für das Einfügen von einer Million Zeilen mit verschiedenen Indizierungsstrategien Nur state_id
Sowohl state_id als auch state_id_2
InnoDB, genug Speicher für beide Indizes
80 Sekunden
136 Sekunden
MyISAM, Speicher reicht nur für einen Index
72 Sekunden
470 Sekunden
Wie Sie sehen, verläuft das Einfügen neuer Zeilen in die Tabelle mit mehr Indizes deutlich langsamer. Im Allgemeinen ist das tatsächlich so: Das Hinzufügen neuer Indizes kann starke Auswirkungen auf die Leistung von INSERT-, UPDATE- und DELETE-Operationen haben, vor allem, wenn Sie aufgrund eines neuen Index an die Grenzen des Speichers stoßen.
Indizes und Locking Indizes spielen für InnoDB eine sehr wichtige Rolle, weil sie dafür sorgen, dass Abfragen weniger Zeilen sperren. Das ist ein sehr wichtiger Fakt, da InnoDB in MySQL 5.0 eine Zeile erst dann wieder entsperrt, wenn die Transaktion bestätigt wird. Wenn Ihre Abfragen nicht benötigte Zeilen niemals anfassen, dann sperren sie weniger Zeilen, was aus zwei Gründen besser für die Leistung ist. Erstens: Obwohl Zeilen-Locks von InnoDB sehr effizient sind und wenig Speicher benötigen, verursachen sie dennoch einen gewissen Overhead. Zweitens: Das Sperren von mehr Zeilen als nötig erhöht die Konkurrenz um die Locks und vermindert die Nebenläufigkeit. InnoDB sperrt Zeilen nur, wenn es auf sie zugreift. Ein Index ist dazu in der Lage, die Anzahl der Zeilen, auf die InnoDB zugreift, und entsprechend die Locks zu verringern. Das funktioniert allerdings nur, wenn InnoDB die unerwünschten Zeilen auf StorageEngine-Ebene herausfiltern kann. Erlaubt der Index InnoDB dies nicht, muss der MySQL-Server eine WHERE-Klausel anwenden, nachdem InnoDB die Zeilen geholt und an die Serverebene zurückgegeben hat. An dieser Stelle ist es zu spät, das Sperren der Zeilen zu vermeiden: InnoDB hat sie bereits gesperrt, und der Server kann sie nicht entsperren. Das ist mit einem Beispiel einfacher zu verstehen. Wir nehmen wieder die Sakila-Beispieldatenbank: mysql> SET AUTOCOMMIT=0; mysql> BEGIN; mysql> SELECT actor_id FROM sakila.actor WHERE actor_id < 5 -> AND actor_id <> 1 FOR UPDATE; +----------+ | actor_id | +----------+ | 2 | | 3 | | 4 | +----------+
138 | Kapitel 3: Schema-Optimierung und Indizierung
Diese Abfrage liefert nur die Zeilen 2 bis 4 zurück, sperrt allerdings die Zeilen 1 bis 4 exklusiv. InnoDB hat Zeile 1 gesperrt, weil der Plan, den MySQL für diese Abfrage gewählt hat, ein Indexbereichszugriff war: mysql> EXPLAIN SELECT actor_id FROM sakila.actor -> WHERE actor_id < 5 AND actor_id <> 1 FOR UPDATE; +----+-------------+-------+-------+---------+--------------------------+ | id | select_type | table | type | key | Extra | +----+-------------+-------+-------+---------+--------------------------+ | 1 | SIMPLE | actor | range | PRIMARY | Using where; Using index | +----+-------------+-------+-------+---------+--------------------------+
Mit anderen Worten: Die einfache Storage-Engine-Operation lautete »beginne am Anfang des Index und hole alle Zeilen, bis actor_id < 5 falsch wird«. Der Server hat InnoDB nichts von der WHERE-Bedingung verraten, die Zeile 1 eliminiert hat. Beachten Sie das Vorhandensein von »Using where« in der Extra-Spalte in EXPLAIN. Dies zeigt an, dass der MySQL-Server einen WHERE-Filter anwendet, nachdem die Storage-Engine die Zeilen zurückliefert.
Zusammenfassung der Indizierungsstrategien Nachdem Sie mehr über die Indizierung erfahren haben, fragen Sie sich vielleicht, wo Sie in Ihren eigenen Tabellen anfangen sollen. Am wichtigsten ist es, die Abfragen zu untersuchen, die Sie am häufigsten ausführen. Denken Sie aber auch an die weniger häufigen Operationen, wie etwa das Einfügen und Aktualisieren von Daten. Versuchen Sie, den oft gemachten Fehler zu vermeiden, Indizes zu erzeugen, ohne zu wissen, welche Abfragen sie benutzen werden, und denken Sie darüber nach, ob all Ihre Indizes zusammen eine optimale Konfiguration formen. Manchmal reicht es, wenn man sich die Abfragen anschaut, feststellt, welche Indizes sie benötigen, und diese hinzufügt. Es kommt aber auch vor, dass man so viele verschiedene Arten von Abfragen hat, dass man nicht für alle perfekte Indizes hinzufügen kann und deshalb einen Kompromiss eingehen muss. Um das beste Maß zu finden, müssen Sie Benchmarks durchführen und Profile erstellen. Schauen Sie sich zuerst die Antwortzeit an. Möglicherweise müssen Sie für jede Abfrage, die zu lange dauert, einen Index hinzufügen. Untersuchen Sie dann die Abfragen, die die meiste Last verursachen (mehr dazu in Kapitel 2), und fügen Sie zu deren Unterstützung Indizes hinzu. Berücksichtigen Sie mögliche Speicher-, CPU oder Festplattenengpässe Ihres Systems. Falls Sie etwa viele lange Aggregatabfragen durchführen, um Zusammenfassungen zu erstellen, dann profitieren Ihre Festplatten möglicherweise von abdeckenden Indizes, die GROUP BY-Abfragen unterstützen. Versuchen Sie nach Möglichkeit, existierende Indizes zu erweitern, anstatt neue anzulegen. Normalerweise ist es effizienter, einen mehrspaltigen Index zu pflegen als mehrere einspaltige Indizes. Falls Sie Ihre Abfrageverteilung noch nicht kennen, dann machen Sie Ihre Indizes so selektiv, wie es geht, da stark selektive Indizes im Allgemeinen mehr Vorteile bieten.
Indizierungsstrategien für High Performance | 139
Hier ist eine zweite Abfrage, die beweist, dass Zeile 1 gesperrt ist, obwohl es in den Ergebnissen der ersten Abfrage nicht auftauchte. Lassen Sie die erste Verbindung offen, starten Sie eine zweite Verbindung, und führen Sie Folgendes aus: mysql> SET AUTOCOMMIT=0; mysql> BEGIN; mysql> SELECT actor_id FROM sakila.actor WHERE actor_id = 1 FOR UPDATE;
Die Abfrage bleibt hängen, da sie darauf wartet, dass die erste Transaktion die Sperre auf Zeile 1 wieder freigibt. Dieses Verhalten ist notwendig, damit die anweisungsbasierte Replikation (Statement-based Replication, SBR; wird in Kapitel 8 besprochen) richtig funktioniert. Wie dieses Beispiel zeigt, kann InnoDB Zeilen, die es eigentlich nicht braucht, sperren, wenn es einen Index benutzt. Das Problem verschlimmert sich sogar noch, wenn es keinen Index einsetzen kann, um die Zeilen zu suchen und zu sperren: Wenn es keinen Index für die Abfrage gibt, führt MySQL einen vollständigen Scan der Tabelle durch und sperrt alle Zeilen, ob es sie nun »braucht« oder nicht.16 Es gibt bezüglich InnoDB, Indizes und Locking noch ein wenig bekanntes Detail: InnoDB kann auf sekundäre Indizes Shared Locks (Lese-Locks) platzieren, exklusive Locks (Schreib-Locks) verlangen allerdings Zugriff auf den Primärschlüssel. Dies eliminiert die Möglichkeit, einen abdeckenden Index zu benutzen, und kann SELECT FOR UPDATE viel langsamer machen als LOCK IN SHARE MODE oder eine nichtsperrende Abfrage.
Indizierung – eine Fallstudie Zum besseren Verständnis der Indizierungskonzepte haben wir eine Fallstudie vorbereitet. Nehmen Sie an, wir müssen eine Online-Dating-Site entwerfen, auf der es Benutzerprofile mit vielen verschiedenen Spalten gibt, wie z.B. Land des Benutzers, Bundesland/Region, Stadt, Geschlecht, Alter, Augenfarbe usw. Die Site muss das Durchsuchen der Profile anhand verschiedener Kombinationen dieser Eigenschaften unterstützen. Darüber hinaus soll der Benutzer die Ergebnisse nach dem letzten Zeitpunkt seiner Anmeldung, nach Bewertungen anderer Benutzer usw. sortieren und einschränken können. Wie entwirft man Indizes für solche komplexen Anforderungen? Seltsamerweise müssen wir zuerst entscheiden, ob wir eine indexbasierte Sortierung benutzen müssen oder ob ein Filesort akzeptabel ist. Eine indexbasierte Sortierung verursacht Einschränkungen bezüglich des Aufbaus der Indizes und Abfragen. Beispielsweise können wir keinen Index für eine WHERE-Klausel wie WHERE age BETWEEN 18 AND 25 verwenden, wenn die gleiche Abfrage einen Index benutzt, um die Benutzer nach den Bewertungen zu sortieren, die die anderen Benutzer ihnen gegeben haben. Wenn MySQL einen 16 Dies sollte in MySQL 5.1 mit zeilenbasiertem Binär-Logging und der Transaktionsisolationsebene READ COMMITTED behoben werden, gilt aber für alle MySQL-Versionen, die wir getestet haben, bis einschließlich 5.1.22.
140 | Kapitel 3: Schema-Optimierung und Indizierung
Index für ein Bereichskriterium in einer Abfrage verwendet, kann es nicht auch noch einen anderen Index (oder ein Suffix des gleichen Index) für die Sortierung einsetzen. Unter der Annahme, dass dies eine der gebräuchlichsten WHERE-Klauseln ist, gehen wir davon aus, dass viele Abfragen ein Filesort brauchen.
Viele Arten der Filterung unterstützen Jetzt müssen wir uns anschauen, welche Spalten viele verschiedene Werte aufweisen und welche Spalten am häufigsten in den WHERE-Klauseln auftauchen. Indizes in Spalten mit vielen unterschiedlichen Werten sind sehr selektiv. Das ist im Allgemeinen ganz günstig, da es MySQL erlaubt, unerwünschte Zeilen effizienter auszufiltern. Die country-Spalte kann selektiv sein oder nicht, sie wird wahrscheinlich in den meisten Abfragen vorkommen. Die sex-Spalte ist sicher nicht selektiv, tritt aber wahrscheinlich in jeder Abfrage in Erscheinung. Mit diesem Wissen erzeugen wir eine Reihe von Indizes für viele verschiedene Kombinationen aus Spalten, denen (sex,country) als Präfix vorangestellt ist. Traditionell wird davon ausgegangen, dass es sinnlos ist, Spalten mit sehr niedriger Selektivität zu indizieren. Weshalb sollen wir dann eine nichtselektive Spalte an den Anfang jedes Index setzen? Haben wir den Verstand verloren? Es gibt dafür zwei Gründe. Der erste Grund besteht darin, dass, wie bereits angemerkt, fast jede Abfrage sex verwenden wird. Wir könnten die Site sogar so gestalten, dass die Benutzer immer nur nach einem Geschlecht gleichzeitig suchen können. Wichtiger ist aber, dass es eigentlich keinen großen Nachteil darstellt, die Spalte hinzuzufügen, weil wir noch ein Ass im Ärmel haben. Und so geht der Trick: Selbst wenn eine Abfrage ausgeführt wird, die die Ergebnisse nicht nach dem Geschlecht einschränkt, können wir sicherstellen, dass der Index benutzbar bleibt, indem wir zur WHERE-Klausel AND sex IN('m', 'f') hinzufügen. Damit werden keine Zeilen ausgefiltert, funktional ist es also das Gleiche, als würde man die sex-Spalte nicht in die WHERE-Klausel einfügen. Wir müssen jedoch diese Spalte einfügen, weil sie es MySQL erlaubt, ein größeres Präfix für den Index zu benutzen. Dieser Trick eignet sich für solche Situationen; wenn die Spalte jedoch viele verschiedene Werte aufweist, dann funktioniert er nicht so gut, weil die IN( )-Liste zu groß werden würde. Dieser Fall verdeutlicht ein allgemeines Prinzip: Spielen Sie alle Möglichkeiten durch. Wenn Sie Indizes entwerfen, dann denken Sie nicht nur an die Arten von Indizes, die Sie für existierende Abfragen benötigen, sondern ziehen Sie es auch in Betracht, die Abfragen zu optimieren. Falls Sie den Bedarf für einen Index sehen, aber der Meinung sind, dass einige Abfragen dadurch leiden könnten, dann fragen Sie sich, ob Sie die Abfragen ändern können. Optimieren Sie Abfragen und Indizes zusammen, um den besten Kompromiss zu finden; es ist nicht nötig, das perfekte Indizierungsschema im luftleeren Raum zu schaffen.
Indizierung – eine Fallstudie | 141
Als Nächstes überlegen wir, welche weiteren Kombinationen aus WHERE-Bedingungen uns wahrscheinlich begegnen werden und welche dieser Kombinationen ohne passende Indizes zu langsam sein werden. Ein Index in (sex, country, age) ist ganz offensichtlich, und vermutlich brauchen wir auch Indizes in (sex, country, region, age) und (sex, country, region, city, age). Das werden immer mehr Indizes. Falls wir Indizes wiederverwenden wollen und das nicht zu viele Kombinationen aus Bedingungen erzeugt, können wir den IN( )-Trick einsetzen und die (sex, country, age)- und (sex, country, region, age)-Indizes ausrangieren. Sind sie nicht im Suchformular angegeben, dann können wir dafür sorgen, dass das Indexpräfix Gleichheits-Constraints enthält, indem wir eine Liste aller Länder oder aller Regionen des Landes festlegen. (Kombinierte Listen aller Länder, aller Regionen und aller Geschlechter wären wahrscheinlich zu groß.) Diese Indizes bedienen die am häufigsten auftretenden Suchabfragen. Doch wie können wir Indizes für weniger häufig auftretende Möglichkeiten entwerfen, wie z.B. has_pictures, eye_color, hair_color und education? Wenn diese Spalten nicht sehr selektiv sind und nicht oft benutzt werden, dann können wir sie einfach überspringen und MySQL ein paar zusätzliche Zeilen scannen lassen. Alternativ können wir sie vor der ageSpalte einfügen und die bereits beschriebene IN( )-Technik einsetzen, um den Fall zu behandeln, in dem sie nicht angegeben sind. Sie haben vielleicht bemerkt, dass wir die age-Spalte am Ende des Index halten. Was ist das Besondere an dieser Spalte, und wieso sollte sie am Ende des Index stehen? Wir versuchen sicherzustellen, dass MySQL so viele Spalten des Index benutzt wie möglich, da es nur das am weitesten links gelegene Präfix einsetzt, bis zu und einschließlich der ersten Bedingung, die einen Bereich aus Werten festlegt. Alle anderen Spalten, die wir erwähnt haben, können Gleichheitsbedingungen in der WHERE-Klausel verwenden, age jedoch ist ziemlich sicher ein Bereich (z.B. age BETWEEN 18 AND 25). Wir könnten das in eine IN( )-Liste umwandeln, also etwa age IN(18, 19, 20, 21, 22, 23, 24, 25), das ist für diese Art von Abfrage aber nicht immer möglich. Das allgemeine Prinzip, das wir verdeutlichen wollen, besteht darin, das Bereichskriterium am Ende des Index zu behalten, damit der Optimierer so viel wie möglich des Index benutzt. Wir haben gesagt, dass Sie immer mehr Spalten zum Index hinzufügen und IN( )-Listen einsetzen können, um Fälle abzudecken, in denen diese Spalten nicht Teil der WHEREKlausel sind. Sie können es aber auch übertreiben und Probleme bekommen. Werden nämlich mehr als nur einige wenige Listen verwendet, dann explodiert förmlich die Anzahl der Kombinationen, die der Optimierer auswerten muss, und das kann die Abfragegeschwindigkeit unweigerlich herabsetzen. Betrachten Sie die folgende WHERE-Klausel: WHERE eye_color IN('brown','blue','hazel') AND hair_color IN('black','red','blonde','brown') AND sex IN('M','F')
Der Optimierer wandelt dies in 4*3*2 = 24 Kombinationen um, die WHERE-Klausel muss diese alle überprüfen. Vierundzwanzig ist noch keine übermäßig große Zahl, seien Sie
142 | Kapitel 3: Schema-Optimierung und Indizierung
aber vorsichtig, wenn dieser Wert in die Tausende geht. Ältere MySQL-Versionen hatten mehr Probleme mit vielen IN( )-Kombinationen: Die Optimierung der Abfragen konnte länger dauern als deren Ausführung und eine Menge Speicher belegen. Neuere MySQLVersionen stoppen die Bewertung von Kombinationen, wenn deren Anzahl zu groß wird, allerdings schränkt das dann ein, wie gut MySQL den Index benutzen kann.
Was ist eine Bereichsbedingung? Die Ausgabe von EXPLAIN lässt manchmal nur schwer erkennen, ob MySQL tatsächlich nach einem Bereich von Werten sucht oder nach einer Liste von Werten. EXPLAIN benutzt den gleichen Begriff, nämlich »range« (Bereich), um beide zu kennzeichnen. So nennt z.B. MySQL das Folgende eine »Bereichsabfrage«, wie Sie in der Spalte type erkennen können: mysql> EXPLAIN SELECT actor_id FROM sakila.actor -> WHERE actor_id > 45\G ************************* 1. row ************************* id: 1 select_type: SIMPLE table: actor type: range
Aber was ist hiermit? mysql> EXPLAIN SELECT actor_id FROM sakila.actor -> WHERE actor_id IN(1, 4, 99)\G ************************* 1. row ************************* id: 1 select_type: SIMPLE table: actor type: range
Es gibt keine Möglichkeit, den Unterschied festzustellen, indem man sich EXPLAIN anschaut, aber wir ziehen eine Trennlinie zwischen Bereichen von Werten und mehrfachen Gleichheitsbedingungen. Bei der zweiten Abfrage handelt es sich in unserer Terminologie um eine mehrfache Gleichheitsbedingung. Wir sind nicht einfach nur pingelig: Diese beiden Arten von Indexzugriffen funktionieren unterschiedlich. Die Bereichsbedingung sorgt dafür, dass MySQL alle weiteren Spalten in dem Index ignoriert, die mehrfache Gleichheitsbedingung dagegen unterliegt nicht dieser Einschränkung.
Mehrfache Bereichsbedingungen vermeiden Nehmen wir an, wir haben eine Spalte namens last_online und wollen den Benutzern zeigen können, wer in der letzten Woche online war: WHERE AND AND AND AND
eye_color hair_color sex last_online age
IN('brown','blue','hazel') IN('black','red','blonde','brown') IN('M','F') > DATE_SUB('2008-01-17', INTERVAL 7 DAY) BETWEEN 18 AND 25
Indizierung – eine Fallstudie | 143
Es gibt mit dieser Abfrage ein Problem: Sie enthält zwei Bereichsbedingungen. MySQL kann entweder das Kriterium last_online benutzen oder das Kriterium age, aber nicht beide. Wenn die Einschränkung last_online ohne die Einschränkung age erscheint oder wenn sich last_online selektiver verhält als age, dann möchten wir vielleicht noch eine weitere Gruppe von Indizes mit last_online am Ende hinzufügen. Aber was ist, wenn wir age nicht in eine IN( )-Liste umwandeln können und den Geschwindigkeitszuwachs brauchen, den das gleichzeitige Beschränken durch last_online und age bringt? Im Moment gibt es keine Möglichkeit, dies direkt zu erreichen, aber wir können einen der Bereiche in einen Gleichheitsvergleich umwandeln. Dazu fügen wir die vorberechnete Spalte active hinzu, die wir mithilfe eines periodisch ausgeführten Jobs pflegen. Wir setzen die Spalte auf 1, wenn sich der Benutzer anmeldet, der Job setzt sie wieder zurück auf 0, wenn sich der Benutzer in den folgenden sieben Tagen nicht anmeldet. Dieser Ansatz erlaubt es MySQL, Indizes wie (active, sex, country, age) zu benutzen. Die Spalte ist vielleicht nicht absolut akkurat, aber diese Art von Abfrage verlangt wahrscheinlich keinen so hohen Grad an Akkuratesse. Wenn wir Genauigkeit brauchen, können wir die Bedingung last_online in der WHERE-Klausel lassen, indizieren sie aber nicht. Diese Technik ähnelt derjenigen, die wir weiter vorn in diesem Kapitel benutzt haben, um HASH-Indizes für URL-Lookups zu simulieren. Die Bedingung benutzt keinen Index, aber da es unwahrscheinlich ist, dass man viele der Zeilen verwirft, die ein Index finden würde, wäre ein Index sowieso nicht so sinnvoll. Oder anders ausgedrückt, das Fehlen eines Index würde die Abfrage nicht merklich beeinträchtigen. Vermutlich erkennen Sie inzwischen das Muster: Wenn ein Benutzer sowohl aktive als auch inaktive Ergebnisse sehen möchte, können wir eine IN( )-Liste hinzufügen. Wir haben viele dieser Listen angelegt; die Alternative besteht darin, separate Indizes zu erzeugen, die jede Kombination aus Spalten bedienen können, die wir filtern müssen. Wir müssen wenigstens die folgenden Indizes einsetzen: (active, sex, country, age), (active, country, age), (sex, country, age) und (country, age). Solche Indizes wären zwar für jede spezielle Abfrage der optimale Fall, allerdings macht der zu erwartende Wartungsaufwand in Kombination mit dem erforderlichen Platz dies im Großen und Ganzen zu einer ziemlich schlechten Strategie. Dies ist ein Fall, in dem Änderungen des Optimierers die optimale Indizierungsstrategie wirklich beeinflussen können. Falls eine künftige Version von MySQL in der Lage ist, einen wirklich freien Indexscan durchzuführen, dann sollte es möglich sein, mehrere Bereichsbedingungen in einem einzigen Index einzusetzen, so dass die IN( )-Listen für die speziellen Arten von Abfragen, über die wir hier reden, nicht mehr erforderlich sind.
144 | Kapitel 3: Schema-Optimierung und Indizierung
Das Sortieren optimieren Der letzte Punkt, mit dem wir uns in dieser Fallstudie befassen wollen, ist das Sortieren. Das Sortieren kleiner Ergebnismengen mit Filesorts ist schnell, aber was ist, wenn Millionen von Zeilen einer Abfrage entsprechen? Was wäre z.B., wenn in der WHERE-Klausel nur sex angegeben ist? Wir können besondere Indizes zum Sortieren dieser wenig selektiven Fälle hinzufügen. So kann etwa ein Index in (sex, rating) für die folgende Abfrage benutzt werden: mysql> SELECT <spalten> FROM profiles WHERE sex='M' ORDER BY rating LIMIT 10;
Diese Abfrage besitzt sowohl ORDER BY- als auch LIMIT-Klauseln und wäre ohne den Index sehr langsam. Selbst mit Index kann die Abfrage langsam sein, wenn die Benutzeroberfläche in Seiten unterteilt ist und jemand eine Seite anfordert, die nicht am Anfang liegt. Dieser Fall erzeugt eine schlechte Kombination aus ORDER BY und LIMIT mit einem Offset: mysql> SELECT <spalten> FROM profiles WHERE sex='M' ORDER BY rating LIMIT 100000, 10;
Solche Abfragen können – unabhängig davon, wie sie indiziert werden – zu einem ernsthaften Problem werden, da der hohe Offset dafür sorgt, dass sie die meiste Zeit damit verbringen, eine Menge Daten zu scannen, die sie dann wegwerfen. Denormalisieren, Vorberechnen und Caching sind wahrscheinlich die einzigen Strategien, die bei solchen Abfragen funktionieren. Noch besser ist es, die Anzahl der Seiten zu beschränken, die Sie den Benutzer anschauen lassen. Die Arbeit des Benutzers wird dadurch mit sehr großer Wahrscheinlichkeit nicht beeinflusst, da sich vermutlich niemand wirklich um die 10.000. Seite mit Suchergebnissen kümmert. Eine weitere gute Strategie zum Optimieren solcher Abfragen besteht darin, einen abdeckenden Index zu verwenden, um nur die Primärschlüsselspalten der Zeilen zu beziehen, die Sie schließlich abrufen werden. Sie können dies dann wieder mit der Tabelle verbinden, um alle gewünschten Spalten zu erhalten. Damit wird die Arbeit verringert, die MySQL verrichten muss, um Daten zu sammeln, die es dann doch nur wegwirft. Hier ist ein Beispiel, das einen Index in (sex, rating) verlangt, um effizient zu funktionieren: mysql> SELECT <Spalten> FROM profiles INNER JOIN ( -> SELECT FROM profiles -> WHERE x.sex='M' ORDER BY rating LIMIT 100000, 10 -> ) AS x USING();
Index- und Tabellenpflege Wenn Sie Tabellen mit richtigen Datentypen erzeugt und Indizes hinzugefügt haben, ist Ihre Arbeit noch nicht beendet: Sie müssen die Tabellen und Indizes pflegen, damit diese auch gut funktionieren. Die drei Hauptziele der Tabellenpflege sind das Suchen und Reparieren von Schäden, das Pflegen der exakten Indexstatistiken und das Reduzieren der Fragmentierung.
Index- und Tabellenpflege | 145
Schäden an der Tabelle suchen und reparieren Das Schlimmste, was einer Tabelle passieren kann, ist Beschädigung. Bei der MyISAMStorage-Engine kommen solche Schäden oft aufgrund von Abstürzen vor. Allerdings können bei allen Storage-Engines in Folge von Hardware-Problemen oder internen Bugs an MySQL oder dem Betriebssystem Beschädigungen des Index auftreten. Beschädigte Indizes sind manchmal die Ursache dafür, dass Abfragen falsche Ergebnisse zurückliefern, dass fälschlicherweise duplizierte Schlüssel auftreten, obwohl es gar keine duplizierten Werte gibt, oder dass es sogar zu Sperren und Abstürzen kommt. Wenn Ihnen etwas am Verhalten des Systems seltsam vorkommt – wenn etwa ein Fehler auftritt, der Ihrer Meinung nach nicht geschehen sollte –, dann sollten Sie CHECK TABLE ausführen, um festzustellen, ob die Tabelle beschädigt ist. (Beachten Sie, dass manche Storage-Engines diesen Befehl nicht unterstützen, andere wiederum unterstützen verschiedene Optionen, mit denen man festlegen kann, wie gründlich die Tabelle überprüft werden soll.) CHECK TABLE erkennt normalerweise die meisten Tabellen- und Indexfehler. Sie können beschädigte Tabellen mit dem Befehl REPAIR TABLE reparieren, allerdings unterstützen nicht alle Storage-Engines diesen Befehl. In diesen Fällen führen Sie einen »leeren« ALTER-Befehl aus, »ändern« also die Tabelle derart, dass sie die gleiche StorageEngine wie zuvor benutzt. Hier ist ein Beispiel für eine InnoDB-Tabelle: mysql> ALTER TABLE innodb_tbl ENGINE=INNODB;
Alternativ können Sie entweder ein offline ausgeführtes, engine-spezifisches Reparaturprogramm wie myisamchk einsetzen oder einen Dump der Daten erzeugen und die Daten dann neu laden. Falls der Schaden sich jedoch im Systembereich befindet oder im »Zeilendaten«-Bereich der Tabelle anstatt im Index, dann helfen Ihnen diese Möglichkeiten nicht weiter. Sie müssten dann versuchen, die Tabelle aus Ihren Backups wiederherzustellen oder zumindest die Daten aus den beschädigten Dateien zu retten (siehe Kapitel 11).
Indexstatistiken aktualisieren Der MySQL-Abfrageoptimierer fragt die Storage-Engines mithilfe von zwei API-Aufrufen, wie die Indexwerte verteilt sind, wenn er entscheidet, wie die Indizes benutzt werden sollen. Der erste Aufruf lautet records_in_range( ). Er akzeptiert Bereichsendpunkte und liefert die (möglicherweise geschätzte) Anzahl an Datensätzen in diesem Bereich zurück. Der zweite Aufruf ist info( ), der verschiedene Arten von Daten zurückliefern kann, einschließlich der Indexkardinalität (also wie viele Datensätze es für jeden Schlüsselwert gibt). Wenn die Storage-Engine dem Optimierer keine exakten Informationen über die Anzahl der Zeilen übermittelt, die eine Abfrage untersuchen wird, verwendet der Optimierer die Indexstatistiken, die Sie mittels ANALYZE TABLE erneuern, um die Anzahl der Zeilen abzuschätzen. Der MySQL-Optimierer ist kostenbasiert, und das wichtigste Maß für die Kosten ist, auf wie viele Daten die Abfrage zugreifen wird. Wenn die Statistiken noch nie
146 | Kapitel 3: Schema-Optimierung und Indizierung
erzeugt wurden oder wenn sie nicht mehr auf dem neuesten Stand sind, trifft der Optimierer möglicherweise schlechte Entscheidungen. Die Lösung besteht darin, ANALYZE TABLE auszuführen. Jede Storage-Engine implementiert die Indexstatistiken anders, so dass Sie im Einzelfall entscheiden müssen, wie oft Sie ANALYZE TABLE ausführen. Auch die Kosten für das Ausführen der Anweisung unterscheiden sich von Storage-Engine zu Storage-Engine: • Die Memory-Storage-Engine speichert Indexstatistiken überhaupt nicht. • MyISAM legt die Statistiken auf der Festplatte ab, und ANALYZE TABLE führt einen vollständigen Indexscan durch, um die Kardinalität zu berechnen. Die gesamte Tabelle ist während dieses Vorgangs gesperrt. • InnoDB speichert keine Statistiken auf der Festplatte, sondern schätzt sie mithilfe von zufälligen Indexzugriffen, wenn die Tabelle das erste Mal geöffnet wird. ANALYZE TABLE benutzt für InnoDB zufällige Indexzugriffe. InnoDB-Statistiken sind daher weniger genau, müssen allerdings wahrscheinlich nicht manuell aktualisiert werden, es sei denn, Sie lassen den Server über einen langen Zeitraum laufen. ANALYZE TABLE ist außerdem in InnoDB nichtblockierend und relativ unaufwendig, so dass Sie die Statistiken online aktualisieren können, ohne dass der Server stark beeinträchtigt werden würde. Sie können die Kardinalität Ihrer Indizes mit dem Befehl SHOW INDEX FROM untersuchen. Zum Beispiel: mysql> SHOW INDEX FROM sakila.actor\G *************************** 1. row *************************** Table: actor Non_unique: 0 Key_name: PRIMARY Seq_in_index: 1 Column_name: actor_id Collation: A Cardinality: 200 Sub_part: NULL Packed: NULL Null: Index_type: BTREE Comment: *************************** 2. row *************************** Table: actor Non_unique: 1 Key_name: idx_actor_last_name Seq_in_index: 1 Column_name: last_name Collation: A Cardinality: 200 Sub_part: NULL Packed: NULL Null: Index_type: BTREE Comment:
Index- und Tabellenpflege | 147
Dieser Befehl liefert Ihnen eine Menge Indexinformationen, die das MySQL-Handbuch genauer erklärt. Wenden Sie Ihre geschätzte Aufmerksamkeit bitte der Spalte Cardinality zu. Diese zeigt, wie viele Einzelwerte die Storage-Engine im Index vermutet. In MySQL 5.0 und neueren Versionen erhalten Sie diese Daten auch aus der Tabelle INFORMATION_ SCHEMA.STATISTICS, was sehr praktisch sein kann. So könnten Sie z.B. Abfragen an die INFORMATION_SCHEMA-Tabellen schreiben, um Indizes mit sehr niedriger Selektivität zu ermitteln.
Index- und Datenfragmentierung verringern B-Baum-Indizes können fragmentiert sein, wodurch sich die Leistung vermindert. Fragmentierte Indizes sind möglicherweise schlecht gefüllt und/oder nichtsequenziell auf der Festplatte. Aufgrund ihres Designs erfordern B-Baum-Indizes zufällige Festplattenzugriffe, um zu den Blattseiten zu gelangen. Zufällige Zugriffe sind also die Regel und nicht die Ausnahme. Die Blattseiten funktionieren jedoch besser, wenn sie physisch sequenziell angeordnet und dicht gepackt sind. Sind sie es nicht, sprechen wir davon, dass sie fragmentiert sind. Bereichsscans oder vollständige Indexscans können in diesem Fall deutlich langsamer vonstatten gehen. Das gilt im Besonderen für indexabdeckende Abfragen. Auch die Datenspeicherung der Tabelle kann fragmentiert werden. Diese Art der Fragmentierung ist jedoch komplexer als die Indexfragmentierung. Es gibt zwei Arten von Datenfragmentierung: Zeilenfragmentierung Diese Art der Fragmentierung tritt auf, wenn die Zeile an mehreren Stellen in mehreren Teilen gespeichert ist. Zeilenfragmentierung vermindert die Performance, selbst wenn die Abfrage nur eine einzige Zeile aus dem Index benötigt. Interne Zeilenfragmentierung Diese Art der Fragmentierung tritt auf, wenn logisch sequenziell angeordnete Seiten oder Zeilen nicht sequenziell auf der Festplatte gespeichert werden. Sie beeinträchtigt Operationen wie vollständige Tabellenscans und Bereichsscans in Cluster-Indizes, die normalerweise von einer sequenziellen Anordnung der Daten auf der Festplatte profitieren. In MyISAM-Tabellen können beide Arten der Fragmentierung auftreten, InnoDB dagegen fragmentiert kurze Zeilen nie. Um die Daten zu defragmentieren, führen Sie entweder OPTIMIZE TABLE aus oder erzeugen einen Dump der Daten und laden die Daten dann wieder. Diese Ansätze funktionieren bei den meisten Storage-Engines. Bei einigen, wie etwa MyISAM, werden dabei gleich die Indizes defragmentiert, indem sie mit einem Sortieralgorithmus neu aufgebaut, das heißt, in der richtigen Reihenfolge neu erstellt werden. Momentan gibt es keine Möglichkeit, InnoDB-Indizes zu defragmentieren, da InnoDB in
148 | Kapitel 3: Schema-Optimierung und Indizierung
MySQL Indizes nicht durch Sortieren aufbauen kann.17 Selbst das Verwerfen und Neuerzeugen von InnoDB-Indizes kann je nach den Daten zu fragmentierten Indizes führen. Bei Storage-Engines, die OPTIMIZE TABLE nicht unterstützen, können Sie die Tabelle mit einem leeren ALTER TABLE-Befehl neu aufbauen. Damit veranlassen Sie, dass die Tabelle dieselbe Engine wie zuvor verwendet: mysql> ALTER TABLE ENGINE=<Engine>;
Normalisierung und Denormalisierung Es gibt normalerweise viele Möglichkeiten, bestimmte Daten darzustellen: von vollständig normalisiert bis vollständig denormalisiert und in beliebigen Abstufungen dazwischen. In einer normalisierten Datenbank wird jeder Fakt einmal, und zwar nur einmal abgebildet. Im Gegenzug werden Informationen in einer denormalisierten Datenbank dupliziert oder an mehreren Stellen gespeichert. Befassen Sie sich mit Normalisierung, falls Sie damit nicht vertraut sind. Es gibt viele gute Bücher sowie online verfügbare Ressourcen zu dem Thema; wir bieten Ihnen hier nur eine kurze Einführung zu den Aspekten, die Sie für dieses Kapitel kennen sollten. Beginnen wir mit dem klassischen Beispiel von Angestellten, Abteilungen und Abteilungsleitern: ANGESTELLTER
ABTEILUNG
LEITER
Jones
Buchhaltung
Jones
Smith
Entwicklung
Smith
Brown
Buchhaltung
Jones
Green
Entwicklung
Smith
Das Problem mit diesem Schema besteht darin, dass Anomalien auftreten können, wenn die Daten modifiziert werden. Nehmen wir an, Brown wird zum Chef der Buchhaltung. Wir müssen mehrere Zeilen aktualisieren, um diese Änderung zu übernehmen. Während dieser Aktualisierungen befinden sich die Daten in einem inkonsistenten Zustand. Wenn sich der Abteilungsleiter in der »Jones«-Zeile von dem in der »Brown«-Zeile unterscheidet, gibt es keine Möglichkeit festzustellen, was richtig ist. Es ist wie in dem Spruch: »Jemand mit zwei Uhren weiß nicht, wie spät es wirklich ist«. Darüber hinaus können wir eine Abteilung nie ohne Angestellte darstellen – wenn wir alle Angestellten in der Buchhaltungsabteilung löschen, verlieren wir alle Datensätze über die Abteilung selbst. Um diese Probleme zu umgehen, müssen wir die Tabelle normalisieren, indem wir die Angestellten- und die Abteilungseinheiten trennen. Das führt zu den folgenden zwei Tabellen für die Angestellten:
17 Die InnoDB-Entwickler arbeiten momentan daran, dieses Problem zu lösen.
Normalisierung und Denormalisierung | 149
ANGESTELLTENNAME
ABTEILUNG
Jones
Buchhaltung
Smith
Entwicklung
Brown
Buchhaltung
Green
Entwicklung
und folgenden Abteilungen: ABTEILUNG
LEITER
Buchhaltung
Jones
Entwicklung
Smith
Diese Tabellen sind nun in der zweiten Normalform, was für viele Zwecke ausreichend ist. Allerdings stellt die zweite Normalform nur eine von vielen möglichen Normalformen dar. Wir verwenden hier zur Verdeutlichung den Nachnamen als Primärschlüssel, da er der »natürliche Identifikator« der Daten ist. In der Praxis würden Sie das natürlich nicht tun. Er ist nicht unbedingt eindeutig, und außerdem sollte man normalerweise keinen langen String als Primärschlüssel benutzen.
Vor- und Nachteile eines normalisierten Schemas Leute, die aufgrund von Performance-Problemen um Hilfe bitten, werden oft aufgefordert, ihre Schemata zu normalisieren, vor allem, wenn die Operationen sehr schreiblastig sind. Das ist meist ein guter Rat, und zwar aus folgenden Gründen: • Normalisierte Updates sind üblicherweise schneller als denormalisierte Updates. • Wenn die Daten gut normalisiert sind, gibt es kaum oder keine duplizierten Daten, so dass weniger Daten zu ändern sind. • Normalisierte Tabellen sind meist kleiner, passen also besser in den Speicher und funktionieren besser. • Das Fehlen redundanter Daten bedeutet, dass weniger Bedarf an DISTINCT- oder GROUP BY-Abfragen besteht, wenn Listen mit Werten bezogen werden müssen. Denken Sie an das vorgestellte Beispiel: Es ist nicht möglich, ohne DISTINCT oder GROUP BY eine eindeutige Liste der Abteilungen aus einem denormalisierten Schema zu erhalten. Wenn ABTEILUNG dagegen eine eigene Tabelle ist, dann ist die Abfrage trivial. Die Nachteile eines normalisierten Schemas haben üblicherweise mit der Abfrage zu tun. Jede nichttriviale Abfrage in einem gut normalisierten Schema verlangt wahrscheinlich wenigstens einen, vielleicht sogar mehrere Joins. Das ist nicht nur teuer, sondern kann
150 | Kapitel 3: Schema-Optimierung und Indizierung
einige Indizierungsstrategien sogar vereiteln. Beispielsweise könnten durch eine Normalisierung Spalten in unterschiedliche Tabellen gelangen, für die es besser wäre, wenn sie zum gleichen Index gehörten.
Vor- und Nachteile eines denormalisierten Schemas Ein denormalisiertes Schema funktioniert, weil alles sich in derselben Tabelle befindet, wodurch Joins vermieden werden. Wenn Sie Tabellen nicht zusammenführen müssen, dann ist das Schlimmste für die meisten Abfragen – selbst für die, die keine Indizes verwenden – ein vollständiger Tabellenscan. Dieser kann viel schneller sein als ein Join, wenn die Daten nicht in den Speicher passen, weil er willkürliche Ein-/Ausgaben vermeidet. Eine einzelne Tabelle kann außerdem effizientere Indizierungsstrategien zulassen. Nehmen Sie an, Sie haben eine Website, auf der Benutzer ihre Nachrichten veröffentlichen. Einige Benutzer sind Premium-Benutzer. Nehmen Sie weiterhin an, Sie wollen die letzten zehn Nachrichten der jeweiligen Premium-Benutzer anzeigen lassen. Wenn Sie dieses Schema normalisiert und die Veröffentlichungsdaten der Nachrichten indiziert hätten, dann könnte die Abfrage so aussehen: mysql> -> -> -> ->
SELECT message_text, user_name FROM message INNER JOIN user ON message.user_id=user.id WHERE user.account_type='premium' ORDER BY message.published DESC LIMIT 10;
Um diese Abfrage effizient auszuführen, muss MySQL den Index published in der Tabelle message durchsuchen. Für jede Zeile, die es findet, muss es in die Tabelle user schauen und überprüfen, ob der Benutzer ein Premium-Benutzer ist. Das ist ineffizient, wenn nur ein Bruchteil der Benutzer einen Premium-Zugang besitzt. Der andere mögliche Abfrageplan sieht vor, mit der user-Tabelle zu beginnen, alle Premium-Benutzer auszuwählen, alle Nachrichten für sie zu holen und einen Filesort durchzuführen. Das ist wahrscheinlich sogar noch schlimmer. Das Problem ist der Join, der Sie davon abhält, gleichzeitig mit einem einzigen Index zu sortieren und zu filtern. Wenn Sie die Daten denormalisieren, indem Sie die Tabellen miteinander kombinieren und einen Index in (account_type, published) hinzufügen, können Sie die Abfrage ohne Join schreiben. Das ist dann wiederum sehr effizient: mysql> -> -> -> ->
SELECT message_text,user_name FROM user_messages WHERE account_type='premium' ORDER BY published DESC LIMIT 10;
Normalisierung und Denormalisierung | 151
Ein Mix aus normalisiert und denormalisiert Wie sollen Sie nun das beste Design wählen, wenn sowohl normalisierte als auch denormalisierte Schemata Vor- und Nachteile aufweisen? Um ehrlich zu sein, sind vollständig normalisierte und vollständig denormalisierte Schemata wie Laborratten: Sie haben üblicherweise mit dem richtigen Leben wenig zu tun. Im richtigen Leben muss man oft die verschiedenen Ansätze mischen, d.h., ein teilweise normalisiertes Schema, Cache-Tabellen und andere Techniken verwenden. Die gebräuchlichste Methode, um Daten zu denormalisieren, besteht darin, ausgewählte Spalten von einer Tabelle in eine andere zu duplizieren oder im Cache zu speichern. Seit MySQL 5.0 können Sie Trigger verwenden, um die im Cache abgelegten Werte zu aktualisieren, was die Implementierung vereinfacht. Anstatt z.B. in unserem Website-Beispiel vollständig zu denormalisieren, können Sie account_type sowohl in der user- als auch in der message-Tabelle speichern. Dadurch vermeiden Sie Probleme beim Einfügen und Löschen, die bei einer vollständigen Denormalisierung auftreten, weil Sie niemals die Informationen über den Benutzer verlieren, selbst wenn es keine Nachrichten gibt. Die Tabelle user_message wird dadurch nicht viel größer, Sie können aber die Daten effizient auswählen. Es ist nun jedoch aufwendiger, den Zugangstyp eines Benutzers zu aktualisieren, da Sie diesen in beiden Tabellen ändern müssen. Um herauszufinden, ob das ein Problem darstellt, müssen Sie überlegen, wie oft Sie solche Änderungen vornehmen und wie lange sie dauern, und dies damit vergleichen, wie oft Sie eine SELECT-Abfrage ausführen. Ein weiterer guter Grund dafür, einige der Daten von der Elterntabelle in die Kindtabelle zu verschieben, ist die Sortierung. Es wäre z.B. außerordentlich teuer, die Nachrichten in einem normalisierten Schema nach dem Namen des Autors zu sortieren. Sie können eine solche Sortierung dagegen sehr effizient vornehmen, wenn Sie den author_name in der message-Tabelle zwischenspeichern und indizieren. Auch das Speichern von abgeleiteten Werten im Cache kann sehr nützlich sein. Falls Sie anzeigen müssen, wie viele Nachrichten die jeweiligen Benutzer veröffentlicht haben (wie es viele Foren tun), können Sie entweder eine aufwendige Unterabfrage ausführen, um die Daten jedes Mal zu zählen, wenn Sie sie anzeigen, oder Sie legen eine num_messagesSpalte in der user-Tabelle an, die Sie immer dann aktualisieren, wenn ein Benutzer eine neue Nachricht veröffentlicht.
Cache- und Summary-Tabellen Manchmal besteht die beste Methode, um die Leistung zu verbessern, darin, redundante Daten in der gleichen Tabelle abzulegen wie die Daten, aus denen sie abgeleitet wurden. Dann wiederum müssen Sie manchmal aber auch völlig getrennte Summary- oder CacheTabellen erstellen, die speziell an Ihre Anforderungen angepasst sind. Dieser Ansatz funktioniert am besten, wenn Sie es tolerieren können, dass die Daten nicht mehr ganz
152 | Kapitel 3: Schema-Optimierung und Indizierung
taufrisch sind, aber manchmal haben Sie wirklich keine andere Wahl (z.B. wenn Sie komplexe und teure Echtzeit-Updates vermeiden müssen). Die Begriffe »Cache-Tabelle« und »Summary-Tabelle« haben keine standardisierten Bedeutungen. Wir verwenden den Begriff »Cache-Tabelle« für die Bezeichnung von Tabellen, die Daten enthalten, die leicht, wenn auch langsam, aus dem Schema bezogen werden können (d.h. Daten, die logisch redundant sind). Wenn wir »Summary-Tabelle« sagen, dann meinen wir Tabellen, die gesammelte Daten aus GROUP BY-Abfragen enthalten (d.h. Daten, die nicht logisch redundant sind). Manche Leute verwenden auch den Begriff »Roll-up«-Tabellen für diese Tabellen. Um bei dem Website-Beispiel zu bleiben: Stellen Sie sich vor, Sie müssten die Anzahl der Nachrichten zählen, die während der vorangegangenen 24 Stunden veröffentlicht worden sind. Bei einer ausgelasteten Site wäre es unmöglich, einen exakten Echtzeitzähler anzubieten. Stattdessen würden Sie einmal in der Stunde eine Summary-Tabelle generieren. Oft können Sie dies mit einer einzigen Abfrage erledigen, und das ist effizienter, als Zähler in Echtzeit zu unterhalten. Nachteilig ist, dass die Zahlen nicht 100 % exakt sind. Um die exakte Zahl der Nachrichten zu erhalten, die im Laufe der vergangenen 24 Stunden veröffentlicht wurden, gibt es eine andere Option. Beginnen Sie mit einer SummaryTabelle auf Stundenbasis. Sie können dann die exakte Anzahl der Nachrichten ermitteln, die in einem bestimmten 24-Stunden-Zeitraum veröffentlicht wurden, indem Sie die Anzahl der Nachrichten der 23 ganzen Stunden, die in dem Zeitraum enthalten sind, zu der Teilstunde am Anfang und der Teilstunde am Ende addieren. Nehmen Sie an, Ihre Summary-Tabelle heißt msg_per_hr und ist folgendermaßen definiert: CREATE TABLE msg_per_hr ( hr DATETIME NOT NULL, cnt INT UNSIGNED NOT NULL, PRIMARY KEY(hr) );
Sie können die Anzahl der Nachrichten der vorangegangenen 24 Stunden ermitteln, indem Sie die Ergebnisse der folgenden drei Abfragen addieren:18 mysql> -> -> -> mysql> -> -> mysql> ->
SELECT SUM(cnt) FROM msg_per_hr WHERE hr BETWEEN CONCAT(LEFT(NOW( ), 14), '00:00') - INTERVAL 23 HOUR AND CONCAT(LEFT(NOW( ), 14), '00:00') - INTERVAL 1 HOUR; SELECT COUNT(*) FROM message WHERE posted >= NOW( ) - INTERVAL 24 HOUR AND posted < CONCAT(LEFT(NOW( ), 14), '00:00') - INTERVAL 23 HOUR; SELECT COUNT(*) FROM message WHERE posted >= CONCAT(LEFT(NOW( ), 14), '00:00');
Beide Ansätze – ein ungenaues Zählen oder ein exaktes Zählen mit kleinen Bereichsabfragen, um die Lücken zu füllen – sind effizienter, als alle Zeilen in der message-Tabelle zu zählen. Das ist der wesentliche Grund für das Erzeugen von Summary-Tabellen. Diese 18 Wir benutzen LEFT(NOW( ), 14), um das aktuelle Datum und die Uhrzeit auf die nächste Stunde zu runden.
Normalisierung und Denormalisierung | 153
Statistiken sind in Echtzeit aufwendig zu berechnen, da sie das Scannen vieler Daten erfordern oder Abfragen verlangen, die nur mit bestimmten Indizes effizient laufen, die Sie aber aufgrund der Auswirkungen, die diese auf die Updates haben, nicht hinzufügen wollen. Das Ermitteln der aktivsten Benutzer oder der am häufigsten verwendeten »Tags« sind typische Beispiele für solche Operationen. Cache-Tabellen sind wiederum sinnvoll zum Optimieren von Such- und Retrieval-Abfragen. Diese Abfragen verlangen oft eine Tabellen- und Indexstruktur, die sich von der für allgemeine OLTP-Operationen (Online Transaction Processing) unterscheidet. So brauchen Sie z.B. viele unterschiedliche Indexkombinationen, um die verschiedenen Arten von Abfragen zu beschleunigen. Diese widersprüchlichen Anforderungen erfordern es manchmal, dass Sie eine Cache-Tabelle erzeugen, die nur einige der Spalten aus der Haupttabelle enthält. Eine sinnvolle Technik ist es, eine andere Storage-Engine für die Cache-Tabelle zu benutzen. Wenn die Haupttabelle z.B. InnoDB benutzt, dann bekommen Sie, wenn Sie MyISAM für die Cache-Tabelle benutzen, eine kleinere Indexbasis sowie die Fähigkeit, Volltextsuchabfragen durchzuführen. Manchmal wollen Sie vielleicht sogar eine Tabelle vollständig aus MySQL herausnehmen und in ein spezialisiertes System bringen, das effizienter suchen kann, wie etwa die Lucene- oder SphinxSuchmaschinen. Wenn Sie Cache- und Summary-Tabellen benutzen, müssen Sie entscheiden, ob Sie deren Daten in Echtzeit oder mit periodisch wiederkehrenden Neuaufbauten pflegen. Welche Wahl besser ist, hängt von Ihrer Anwendung ab. Ein periodisch wiederkehrender Neuaufbau kann nicht nur Ressourcen sparen, sondern auch zu einer effizienteren Tabelle führen, die nicht fragmentiert ist und vollständig sortierte Indizes besitzt. Beim Neuaufbauen von Summary- und Cache-Tabellen müssen Sie oft dafür sorgen, dass deren Daten während der Operation verfügbar bleiben. Dies erreichen Sie z.B. mithilfe einer »Schattentabelle«, also einer Tabelle, die Sie »hinter« der echten Tabelle aufbauen. Wenn Sie mit dem Aufbau fertig sind, können Sie die Tabellen mit einem atomaren Umbenennen wechseln. Falls Sie etwa my_summary neu aufbauen müssen, erzeugen Sie my_summary_new, füllen die Tabelle mit Daten und vertauschen sie mit der echten Tabelle: mysql> DROP TABLE IF EXISTS my_summary_new, my_summary_old; mysql> CREATE TABLE my_summary_new LIKE my_summary; -- populate my_summary_new as desired mysql> RENAME TABLE my_summary TO my_summary_old, my_summary_new TO my_summary;
Falls Sie, wie wir es hier getan haben, die Original-my_summary-Tabelle my_summary_old nennen, bevor Sie den Namen my_summary der neu aufgebauten Tabelle zuweisen, können Sie die alte Version behalten, bis Sie sie beim nächsten Neuaufbau überschreiben. Das kann sich als praktisch erweisen, falls es mit der neuen Tabelle ein Problem gibt und Sie zurückrudern müssen.
154 | Kapitel 3: Schema-Optimierung und Indizierung
Zählertabellen Eine Anwendung, die Zähler in einer Tabelle führt, kann beim Aktualisieren der Zähler Probleme mit der Nebenläufigkeit bekommen. Solche Tabellen sind in Webanwendungen sehr gebräuchlich. Damit können Sie die Anzahl der Freunde eines Benutzers, die Anzahl der Downloads einer Datei usw. speichern. Oft bietet es sich an, eine eigene Tabelle für die Zähler anzulegen, um sie klein und schnell zu halten. Die Verwendung einer getrennten Tabelle hilft Ihnen, das Ungültigwerden des Abfrage-Cache zu vermeiden und erlaubt es Ihnen, einige der ausgefeilteren Techniken einzusetzen, die wir Ihnen in diesem Abschnitt zeigen. Der Einfachheit halber nehmen Sie an, Sie haben eine Zählertabelle mit einer einzigen Zeile, die lediglich die Zugriffe (Hits) auf Ihre Website zählt: mysql> CREATE TABLE hit_counter ( -> cnt int unsigned not null -> ) ENGINE=InnoDB;
Jeder Zugriff auf die Website aktualisiert den Zähler: mysql> UPDATE hit_counter SET cnt = cnt + 1;
Das Problem ist, dass diese einzelne Zeile im Prinzip einen globalen »Mutex« für jede Transaktion bildet, die den Zähler aktualisiert. Dadurch werden diese Transaktionen serialisiert. Sie erreichen eine größere Nebenläufigkeit, indem Sie mehr als eine Zeile vorhalten und eine zufällige Zeile aktualisieren. Dies erfordert die folgende Änderung an der Tabelle: mysql> CREATE TABLE hit_counter ( -> slot tinyint unsigned not null primary key, -> cnt int unsigned not null -> ) ENGINE=InnoDB;
Fügen Sie der Tabelle 100 Zeilen hinzu. Jetzt kann die Abfrage einen beliebigen Slot wählen und aktualisieren: mysql> UPDATE hit_counter SET cnt = cnt + 1 WHERE slot = RAND( ) * 100;
Um eine Statistik zu erhalten, benutzen Sie Aggregat-Abfragen: mysql> SELECT SUM(cnt) FROM hit_counter;
Oft wird verlangt, dass gelegentlich neue Zähler gestartet werden müssen (z.B. einmal am Tag). Falls dies der Fall ist, können Sie das Schema leicht ändern: mysql> CREATE TABLE daily_hit_counter ( -> day date not null, -> slot tinyint unsigned not null, -> cnt int unsigned not null, -> primary key(day, slot) -> ) ENGINE=InnoDB;
Für dieses Szenario wollen Sie nicht bereits vorab Zeilen generieren. Stattdessen können Sie ON DUPLICATE KEY UPDATE einsetzen:
Normalisierung und Denormalisierung | 155
mysql> INSERT INTO daily_hit_counter(day, slot, cnt) -> VALUES(CURRENT_DATE, RAND( ) * 100, 1) -> ON DUPLICATE KEY UPDATE cnt = cnt + 1;
Falls Sie die Anzahl der Zeilen verringern wollen, um eine kleinere Tabelle zu erhalten, können Sie einen periodisch auszuführenden Job schreiben, der alle Ergebnisse in Slot 0 zusammenfasst und alle anderen Slots löscht: mysql> UPDATE daily_hit_counter as c -> INNER JOIN ( -> SELECT day, SUM(cnt) AS cnt, MIN(slot) AS mslot -> FROM daily_hit_counter -> GROUP BY day -> ) AS x USING(day) -> SET c.cnt = IF(c.slot = x.mslot, x.cnt, 0), -> c.slot = IF(c.slot = x.mslot, 0, c.slot); mysql> DELETE FROM daily_hit_counter WHERE slot <> 0 AND cnt = 0;
Schnelleres Lesen, langsameres Schreiben Oft braucht man zusätzliche Indizes, redundante Felder oder sogar Cache- und SummaryTabellen, um Leseabfragen zu beschleunigen. Das bringt zwar mehr Arbeit für Schreibabfragen und Wartungsaufgaben mit sich, aber dennoch findet man diese Technik häufig, wenn es um hohe Leistung geht: Die Kosten für die langsameren Schreiboperationen werden durch die deutlichen Geschwindigkeitszuwächse beim Lesen mehr als ausgeglichen. Das ist jedoch nicht der einzige Preis, den Sie für schnellere Leseabfragen zahlen. Auch die Komplexität der Entwicklung vergrößert sich für Lese- und Schreiboperationen.
ALTER TABLE beschleunigen Die Leistung des MySQL-Befehls ALTER TABLE kann bei sehr großen Tabellen zu einem Problem werden. MySQL führt die meisten Umbauten aus, indem es eine leere Tabelle mit der gewünschten neuen Struktur anlegt, alle Daten aus der alten Tabelle in die neue Tabelle einfügt und die alte Tabelle dann löscht. Das kann sehr lange dauern, vor allem, wenn der Speicher knapp bemessen ist und die Tabelle sehr groß ist und viele Indizes besitzt. Viele Leute haben ALTER TABLE-Operationen »durchlitten«, die Stunden oder Tage gebraucht haben. MySQL AB arbeitet daran, das zu verbessern. Einige der kommenden Verbesserungen umfassen eine Unterstützung für »Online«-Operationen, bei denen die Tabelle nicht während der gesamten Operation gesperrt ist. Die InnoDB-Entwickler arbeiten ebenfalls an einer Unterstützung für das Aufbauen von Indizes durch Sortierung. MyISAM unterstützt diese Technik bereits, die das Erstellen von Indizes deutlich beschleunigt und einen kompakten Aufbau des Index bietet. (InnoDB baut seine Indizes momentan zeilenweise in Primärschlüsselreihenfolge auf, was bedeutet, dass die Indexbäume nicht optimal sortiert werden und fragmentiert sind.)
156 | Kapitel 3: Schema-Optimierung und Indizierung
Nicht alle ALTER TABLE-Operationen verursachen Umbauten an der Tabelle. Sie können z.B. den Standardwert einer Spalte auf zwei Arten ändern oder verwerfen (einmal schnell und einmal langsam). Nehmen Sie einmal an, Sie wollen die vorgegebene Ausleihdauer eines Films von 3 auf 5 Tage ändern. Dies ist die aufwendige Methode: mysql> ALTER TABLE sakila.film -> MODIFY COLUMN rental_duration TINYINT(3) NOT NULL DEFAULT 5;
Das Profiling dieser Anweisung mit SHOW STATUS zeigt, dass sie 1.000 Handler-Lese- und 1.000 Einfügevorgänge ausführt. Mit anderen Worten: Sie kopierte die Tabelle in eine neue Tabelle, obwohl sich Art, Größe und »Nullability« der Spalte nicht geändert haben. Theoretisch hätte MySQL das Aufbauen einer neuen Tabelle überspringen können. Der Vorgabewert für die Spalte ist eigentlich in der .frm-Datei der Tabelle gespeichert, so dass man ihn ändern können müsste, ohne die Tabelle selbst anzurühren. MySQL benutzt diese Optimierung noch nicht; dafür sorgt jedoch jedes MODIFY COLUMN für einen Tabellenumbau. Sie können allerdings den Vorgabewert einer Spalte mit ALTER COLUMN19 ändern: mysql> ALTER TABLE sakila.film -> ALTER COLUMN rental_duration SET DEFAULT 5;
Diese Anweisung modifiziert die .frm-Datei und lässt die Tabelle in Ruhe. Daher ist sie sehr schnell.
Nur die .frm-Datei modifizieren Wir haben gesehen, dass das Ändern der .frm-Datei einer Tabelle schnell geht und dass MySQL manchmal eine Tabelle umbaut, obwohl es das nicht muss. Wenn Sie bereit sind, einige Risiken auf sich zu nehmen, können Sie MySQL davon überzeugen, einige andere Arten von Modifikationen auszuführen, ohne die Tabelle umzubauen. Die Technik, die wir gleich demonstrieren wollen, wird nicht unterstützt, ist nicht dokumentiert und funktioniert möglicherweise nicht. Sie benutzen sie auf eigenes Risiko. Wir raten Ihnen, Ihre Daten vorher zu sichern!
Sie können potenziell die folgenden Arten von Operationen ausführen, ohne dass die Tabelle neu aufgebaut wird: • Entfernen (aber nicht Hinzufügen) des AUTO_INCREMENT-Attributs einer Spalte • Hinzufügen, Entfernen oder Ändern von ENUM- und SET-Konstanten. Wenn Sie eine Konstante entfernen und einige Zeilen diesen Wert enthalten, dann liefern Abfragen den Wert als leeren String zurück.
19 ALTER TABLE erlaubt es Ihnen, Spalten mit ALTER COLUMN, MODIFY COLUMN und CHANGE COLUMN zu modifizieren. Alle drei führen unterschiedliche Dinge aus.
ALTER TABLE beschleunigen | 157
Die zugrunde liegende Technik besteht darin, eine .frm-Datei für die gewünschte Tabellenstruktur zu erzeugen und sie an die Stelle der .frm-Datei der existierenden Tabelle zu kopieren: 1. Erzeugen Sie eine leere Tabelle mit exakt demselben Layout, abgesehen von der
gewünschten Änderung (wie etwa hinzugefügten ENUM-Konstanten). 2. Führen Sie FLUSH TABLES WITH READ LOCK aus. Damit werden alle in Benutzung befind-
lichen Tabellen geschlossen, und gleichzeitig wird verhindert, dass Tabellen geöffnet werden. 3. Tauschen Sie die .frm-Dateien. 4. Führen Sie UNLOCK TABLES aus, um den Lese-Lock aufzuheben.
Als Beispiel fügen wir zu der rating-Spalte in sakila.film eine Konstante hinzu. Die aktuelle Spalte sieht so aus: mysql> SHOW COLUMNS FROM sakila.film LIKE 'rating'; +--------+------------------------------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +--------+------------------------------------+------+-----+---------+-------+ | rating | enum('G','PG','PG-13','R','NC-17') | YES | | G | | +--------+------------------------------------+------+-----+---------+-------+
Wir fügen eine PG-14-Bewertung für besorgte Eltern hinzu: mysql> mysql> -> -> mysql>
CREATE TABLE sakila.film_new LIKE sakila.film; ALTER TABLE sakila.film_new MODIFY COLUMN rating ENUM('G','PG','PG-13','R','NC-17', 'PG-14') DEFAULT 'G'; FLUSH TABLES WITH READ LOCK;
Beachten Sie, dass wir den neuen Wert am Ende der Liste mit den Konstanten hinzufügen. Hätten wir ihn in die Mitte gesetzt, also hinter PG-13, würden wir die Bedeutung der existierenden Daten ändern: Vorhandene R-Werte würden zu PG-14 werden, NC-17 zu R usw. Jetzt tauschen wir auf der Kommandozeile des Betriebssystems die .frm-Dateien aus: root:/var/lib/mysql/sakila# mv film.frm film_tmp.frm root:/var/lib/mysql/sakila# mv film_new.frm film.frm root:/var/lib/mysql/sakila# mv film_tmp.frm film_new.frm
Wieder zurück am MySQL-Prompt, können wir die Tabelle entsperren und sehen, dass die Änderungen wirksam werden: mysql> UNLOCK TABLES; mysql> SHOW COLUMNS FROM sakila.film LIKE 'rating'\G *************************** 1. row *************************** Field: rating Type: enum('G','PG','PG-13','R','NC-17','PG-14')
Jetzt müssen wir nur noch die Tabelle verwerfen, die wir zur Unterstützung der Operation angelegt haben: mysql> DROP TABLE sakila.film_new;
158 | Kapitel 3: Schema-Optimierung und Indizierung
Schnell MyISAM-Indizes aufbauen Der übliche Trick zum effizienten Laden von MyISAM-Tabellen besteht darin, die Schlüssel zu deaktivieren, die Daten zu laden und die Schlüssel wieder zu reaktivieren: mysql> ALTER TABLE test.load_data DISABLE KEYS; -- load the data mysql> ALTER TABLE test.load_data ENABLE KEYS;
Das funktioniert, weil es MyISAM erlaubt, das Erstellen der Schlüssel zu verzögern, bis alle Daten geladen sind. An dieser Stelle kann es dann die Indizes durch Sortierung erzeugen. Das ist viel schneller und ergibt einen defragmentierten, kompakten Indexbaum.20 Leider funktioniert das bei eindeutigen (unique) Indizes nicht, weil DISABLE KEYS nur für nicht eindeutige Indizes gilt. MyISAM baut eindeutige Indizes im Speicher auf und prüft die Eindeutigkeit, wenn es die einzelnen Zeilen lädt. Das Laden wird dann außerordentlich langsam, sobald die Größe des Index die Größe des verfügbaren Speichers überschreitet. Wie bei den ALTER TABLE-Hacks im vorhergehenden Abschnitt können Sie diesen Vorgang beschleunigen, wenn Sie etwas mehr Aufwand betreiben und bereit sind, ein gewisses Risiko einzugehen. Das kann sich z.B. beim Laden von Daten aus Backups als nützlich erweisen, wenn Sie bereits wissen, dass alle Daten gültig sind und die Eindeutigkeit nicht mehr überprüft werden muss. Auch dies ist eine nicht dokumentierte, nicht unterstützte Technik. Benutzen Sie sie auf eigenes Risiko, und sichern Sie auf jeden Fall vorher Ihre Daten.
Folgende Schritte müssen Sie unternehmen: 1. Erzeugen Sie eine Tabelle mit der gewünschten Struktur, aber ohne Indizes. 2. Laden Sie die Daten in die Tabelle, um die .MYD-Datei anzulegen. 3. Erzeugen Sie eine weitere leere Tabelle mit der gewünschten Struktur, dieses Mal
einschließlich der Indizes. Dadurch werden die benötigten .frm- und .MYI-Dateien angelegt. 4. Setzen Sie in den Tabellen einen Lese-Lock. 5. Benennen Sie die .frm- und .MYI-Dateien der zweiten Tabelle um, damit MySQL sie
für die erste Tabelle benutzt. 6. Heben Sie den Lese-Lock auf. 7. Erzeugen Sie mit REPAIR TABLE die Indizes der Tabelle. Dadurch werden alle Indizes
durch Sortierung erzeugt, auch die eindeutigen Indizes. Diese Prozedur kann bei sehr großen Tabellen viel schneller vonstatten gehen. 20 MyISAM erstellt Indizes auch durch Sortierung, wenn Sie LOAD DATA INFILE benutzen und die Tabelle leer ist.
ALTER TABLE beschleunigen | 159
Hinweise zu Storage-Engines Wir beschließen dieses Kapitel mit einigen Storage-Engine-spezifischen Schema-Designhinweisen, die Sie beherzigen sollten. Das soll hier keine umfassende Liste werden, wir wollen nur einige wesentliche Faktoren präsentieren, die für das Schema-Design relevant sind.
Die MyISAM-Storage-Engine Tabellen-Locks MyISAM-Tabellen haben Locks auf Tabellenebene. Achten Sie darauf, dass diese nicht zu Engstellen werden. Keine automatisierte Datenwiederherstellung Wenn der MySQL-Server abstürzt oder der Strom ausfällt, müssen Sie Ihre MyISAM-Tabellen überprüfen und möglicherweise reparieren, bevor Sie sie wieder benutzen. Bei großen Tabellen kann das mehrere Stunden dauern. Keine Transaktionen MyISAM-Tabellen unterstützen keine Transaktionen. Um genau zu sein, garantiert MyISAM nicht einmal, dass eine einzelne Anweisung abgeschlossen wird. Wenn z.B. bei einem mehrzeiligen UPDATE auf halbem Wege ein Fehler auftritt, werden einige Zeilen aktualisiert und andere nicht. Nur Indizes werden im Speicher zwischengespeichert MyISAM speichert nur den Index innerhalb des MySQL-Prozesses im Schlüsselpuffer-Cache. Das Betriebssystem speichert die Daten der Tabelle in einem Cache, so dass in MySQL 5.0 ein teurer Betriebssystem-Systemaufruf erforderlich ist, um diese Daten zu holen. Kompakte Speicherung Die Zeilen werden sehr eng nacheinander gespeichert, so dass sie auf einer Festplatte wenig Platz einnehmen und vollständige Tabellenscans bei Daten, die auf der Platte liegen, sehr schnell erfolgen.
Die Memory-Storage-Engine Tabellen-Locks Ebenso wie MyISAM-Tabellen besitzen Memory-Tabellen Tabellen-Locks. Das stellt normalerweise aber kein Problem dar, da Abfragen an Memory-Tabellen üblicherweise sehr schnell sind. Keine dynamischen Zeilen Memory-Tabellen unterstützen keine dynamischen Zeilen (d.h. Zeilen variabler Länge), sie unterstützen also auch keine BLOB- und TEXT-Felder. Selbst ein VARCHAR(5000) wird in ein CHAR(5000) umgewandelt – eine ziemliche Speicherverschwendung, wenn die meisten Werte klein sind.
160 | Kapitel 3: Schema-Optimierung und Indizierung
Hash-Indizes sind der vorgegebene Indextyp Im Gegensatz zu anderen Storage-Engines ist der vorgegebene Indextyp Hash, wenn Sie nicht explizit etwas anderes angeben. Keine Indexstatistiken Memory-Tabellen unterstützen keine Indexstatistiken, weshalb Sie für komplexe Abfragen unter Umständen schlechte Ausführungspläne erhalten. Beim Neustart geht der Inhalt verloren Memory-Tabellen behalten keine Daten auf der Festplatte. Die Daten gehen also verloren, wenn der Server neu gestartet wird, obwohl die Definitionen der Tabellen bleiben.
Die InnoDB-Storage-Engine Transaktionsfähig InnoDB unterstützt Transaktionen sowie vier Transaktionsisolationsebenen. Fremdschlüssel Seit MySQL 5.0 ist InnoDB die einzige mitgelieferte Storage-Engine, die Fremdschlüssel unterstützt. Andere Storage-Engines akzeptieren sie in CREATE TABLE-Anweisungen, erzwingen sie jedoch nicht. Manche Engines von Drittherstellern, wie etwa solidDB für MySQL und PBXT, unterstützen sie ebenfalls auf Storage-EngineEbene. MySQL AB plant, in Zukunft Unterstützung für Fremdschlüssel auf Serverebene hinzuzufügen. Sperren auf Zeilenebene Sperren werden auf Zeilenebene gesetzt, ohne die Notwendigkeit von Lock Escalation und mit nichtblockierenden Select-Zugriffen – normale Select-Zugriffe setzen überhaupt keine Sperren, so dass eine sehr gute Nebenläufigkeit erreicht wird. Multiversionierung InnoDB benutzt eine Multiversion Concurrency Control, so dass die Select-Zugriffe standardmäßig veraltete Daten lesen können. Um genau zu sein, führt die MVCCArchitektur zu einer großen Komplexität und möglicherweise unerwarteten Verhaltensweisen. Sie müssen das InnoDB-Handbuch gründlich studieren, wenn Sie InnoDB einsetzen. Cluster-Bildung nach Primärschlüssel Alle Cluster in InnoDB-Tabellen werden nach dem Primärschlüssel gebildet, was Sie beim Schemaentwurf zu Ihrem Vorteil ausnutzen können. Alle Indizes enthalten die Primärschlüsselspalten Indizes verweisen über den Primärschlüssel auf die Zeilen. Wenn Sie also keinen kurzen Primärschlüssel wählen, werden die Indizes schnell sehr groß. Optimiertes Caching InnoDB legt sowohl Daten als auch Speicher im Puffer-Pool ab. Es baut außerdem automatisch Hash-Indizes auf, um die Zeilenabfrage zu beschleunigen.
Hinweise zu Storage-Engines | 161
Ungepackte Indizes Die Indizes werden nicht mit Präfixkomprimierung gepackt, so dass sie viel größer sein können als für MyISAM-Tabellen. Langsames Laden von Daten Seit MySQL 5.0 optimiert InnoDB die Operationen zum Laden von Daten nicht speziell. Es baut die Indizes zeilenweise auf, anstatt sie nach der Sortierung zu erstellen. Dadurch kann es passieren, dass das Laden der Daten deutlich langsamer erfolgt. Blockierendes AUTO_INCREMENT In Versionen vor MySQL 5.1verwendet InnoDB Sperren auf Tabellenebene, um einen neuen AUTO_INCREMENT-Wert zu generieren. Kein im Cache gespeicherter COUNT(*)-Wert Im Gegensatz zu MyISAM- oder Memory-Tabellen speichern InnoDB-Tabellen die Anzahl der Zeilen in der Tabelle nicht, was bedeutet, dass COUNT(*)-Abfragen ohne WHERE-Klausel nicht optimiert werden können und vollständige Tabellen- oder Indexscans erfordern. Mehr Informationen zu diesem Thema finden Sie in »COUNT( )-Abfragen optimieren« auf Seite 202.
162 | Kapitel 3: Schema-Optimierung und Indizierung
KAPITEL 4
Optimierung der Abfrageleistung
Im vorangegangenen Kapitel haben wir erläutert, wie ein Schema optimiert wird, was eine der notwendigen Bedingungen für High Performance darstellt. Es reicht aber nicht, mit dem Schema zu arbeiten – Sie müssen auch Ihre Abfragen gut entwerfen. Wenn Ihre Abfragen schlecht sind, nützt Ihnen das beste Schema nichts. Abfrageoptimierung, Indexoptimierung und Schema-Optimierung gehen Hand in Hand. Mit zunehmender Erfahrung beim Schreiben von Abfragen in MySQL werden Sie verstehen, wie Sie die Schemata zu gestalten haben, damit diese effiziente Abfragen unterstützen. Und das, was Sie über optimales Schemadesign lernen, beeinflusst wiederum die Art der Abfragen, die Sie schreiben. Dieser Prozess kostet Zeit, so dass wir Sie ermuntern wollen, auch später immer wieder zu diesem und den vorangegangenen Kapiteln zurückzukehren. Dieses Kapitel beginnt mit allgemeinen Überlegungen zum Abfrageentwurf – Dingen, die Sie in Betracht ziehen sollten, wenn eine Abfrage nicht gut funktioniert. Wir gehen anschließend genauer auf die Abfrageoptimierung und die Server-Interna ein. Sie erfahren, wie Sie feststellen können, wie MySQL eine bestimmte Abfrage ausführt, und lernen, wie Sie den Ausführungsplan für eine Abfrage ändern. Schließlich schauen wir uns Stellen an, an denen MySQL Abfragen nicht gut optimiert hat, und untersuchen Optimierungsmuster, die es MySQL ermöglichen, Abfragen effizienter auszuführen. Sie müssen verstehen, wie MySQL Abfragen wirklich ausführt, damit Sie selbst entscheiden können, was effizient oder ineffizient ist, die Stärken von MySQL erkennen und seine Schwächen vermeiden.
Grundlagen langsamer Abfragen: Datenzugriff optimieren Im einfachsten Fall funktioniert eine Abfrage nicht gut, weil sie mit zu vielen Daten konfrontiert wird. Manche Abfragen müssen einfach sehr viele Daten durchsuchen und kommen nicht voran. Allerdings ist das ungewöhnlich – man kann die meisten schlechten Abfragen so ändern, dass sie auf weniger Daten zugreifen. Wir haben festgestellt, dass es
163 |
ganz günstig ist, wenn man eine schlecht funktionierende Abfrage in zwei Schritten analysiert: 1. Stellen Sie fest, ob Ihre Anwendung mehr Daten bezieht, als Sie brauchen. Normaler-
weise bedeutet dies, dass sie auf zu viele Zeilen zugreift. Es kann aber auch heißen, dass sie auf zu viele Spalten zugreift. 2. Stellen Sie fest, ob der MySQL-Server mehr Zeilen analysiert als nötig.
Fragen Sie die Datenbank nach Daten, die Sie nicht brauchen? Manche Abfragen fragen nach mehr Daten, als sie brauchen, und werfen einen Teil davon dann weg. Das bedeutet einen erhöhten Aufwand für den MySQL-Server, vergrößert die Last im Netzwerk1 und verbraucht Speicher sowie CPU-Ressourcen auf dem Anwendungsserver. Hier sind einige typische Fehler: Es werden mehr Zeilen als nötig geholt Oft wird fälschlicherweise angenommen, dass MySQL die Ergebnisse auf Anforderung bereitstellt, anstatt die vollständige Ergebnismenge zu berechnen und zurückzuliefern. Uns begegnet das oft in Anwendungen von Leuten, die mit anderen Datenbanksystemen vertraut sind. Diese Entwickler sind an Techniken gewöhnt, bei denen z.B. eine SELECT-Anweisung ausgeführt wird, die viele Zeilen zurückliefert, dann die ersten N Zeilen geholt werden und die Ergebnismenge anschließend geschlossen wird (wenn etwa auf einer Nachrichten-Site die 100 neuesten Artikel geholt werden, auf der ersten Seite aber nur 10 von ihnen angezeigt werden sollen). Sie glauben, dass MySQL diese 10 Zeilen liefert, und beenden das Ausführen der Abfrage. In Wirklichkeit generiert MySQL die komplette Ergebnismenge. Die Client-Bibliothek holt dann alle Daten und verwirft die meisten. Am besten ist es, der Abfrage eine LIMIT-Klausel hinzuzufügen. Es werden aus einem Mehrtabellen-Join alle Spalten geholt Wenn Sie alle Schauspieler abfragen wollen, die in Academy Dinosaur mitspielen, dann schreiben Sie die Abfrage nicht so: mysql> -> -> ->
SELECT * FROM sakila.actor INNER JOIN sakila.film_actor USING(actor_id) INNER JOIN sakila.film USING(film_id) WHERE sakila.film.title = 'Academy Dinosaur';
Damit werden nämlich alle Spalten aus allen drei Tabellen zurückgeliefert. Schreiben Sie die Abfrage stattdessen folgendermaßen: mysql> SELECT sakila.actor.* FROM sakila.actor...;
1 Der Aufwand im Netzwerk ist dann am größten, wenn sich die Anwendung auf einem anderen Host befindet als der Server. Aber auch, wenn sich MySQL und die Anwendung auf demselben Server befinden, ist die Datenübertragung nicht ganz kostenlos.
164 | Kapitel 4: Optimierung der Abfrageleistung
Es werden alle Spalten geholt Sie sollten immer misstrauisch werden, wenn Sie SELECT * sehen. Brauchen Sie wirklich alle Spalten? Vermutlich nicht. Das Abfragen aller Spalten kann Optimierungen wie abdeckende Indizes vereiteln und verursacht außerdem meist zusätzlichen Aufwand für die Ein-/Ausgabe, den Speicher und die CPU. Manche Datenbankadministratoren verbieten SELECT * aufgrund dieser Tatsache ganz allgemein, um das Risiko von Problemen zu verringern, wenn jemand die Spaltenliste einer Tabelle verändert. Es ist natürlich nicht immer schlecht, wenn man mehr Daten abfragt, als man eigentlich benötigt. Bei vielen Fällen, die wir untersucht haben, wurde uns gesagt, dass dieser verschwenderische Ansatz die Entwicklung vereinfacht, da er es den Entwicklern erlaubt, den gleichen Code an mehreren Stellen einzusetzen. Das ist eine ganz vernünftige Überlegung, solange Ihnen klar ist, welche Auswirkungen sie auf die Ausführungsleistung hat. Es kann auch sinnvoll sein, mehr Daten als nötig zu holen, wenn man in der Anwendung eine Art Caching einsetzt oder irgendeinen anderen Vorteil im Sinn hat. Das Abfragen und Speichern vollständiger Objekte ist manchmal besser, als viele Abfragen durchzuführen, die nur Teile des Objekts holen.
Untersucht MySQL zu viele Daten? Sobald Sie sich sicher sind, dass Ihre Abfragen nur die Daten beziehen, die Sie benötigen, können Sie nach Abfragen suchen, die zu viele Daten untersuchen, wenn sie die Ergebnisse generieren. In MySQL sind dies die einfachsten Maße für die Kosten von Abfragen: • Ausführungszeit • Anzahl der untersuchten Zeilen • Anzahl der zurückgelieferten Zeilen Keines dieser Maße ist wirklich perfekt, um die Kosten einer Abfrage zu messen, allerdings spiegeln sie ungefähr wider, auf wie viele Daten MySQL intern zugreifen muss, um eine Abfrage auszuführen, und lassen Rückschlüsse darauf zu, wie schnell die Abfrage ausgeführt wird. Alle drei Maße werden im Slow-Query-Log protokolliert, weshalb ein Blick in dieses Protokoll eine der besten Möglichkeiten darstellt, Abfragen zu finden, die zu viele Daten analysieren.
Ausführungszeit Wie in Kapitel 2 besprochen wurde, unterliegt die normale Slow-Query-Log-Funktion in MySQL 5.0 und früheren Versionen ernsten Beschränkungen, wie z.B. fehlender Unterstützung für eine ausführliche Protokollierung. Glücklicherweise gibt es Patches, die es Ihnen erlauben, langsame Abfragen mit Mikrosekundenauflösung zu messen und zu protokollieren. Diese Patches sind im MySQL 5.1-Server enthalten, Sie können aber auch frühere Versionen bei Bedarf damit ausstatten. Hüten Sie sich jedoch davor, zu viel Augenmerk auf die Ausführungszeit von Abfragen zu richten. Sie ist ganz hübsch anzuse-
Grundlagen langsamer Abfragen: Datenzugriff optimieren | 165
hen, da es sich um ein objektives Maß handelt, allerdings ist sie unter wechselnden Lastbedingungen nicht konsistent. Andere Faktoren – wie etwa Storage-Engine-Sperren (Tabellen-Locks und Row-Locks), hohe Nebenläufigkeit und die Hardware – können die Ausführungszeiten von Abfragen ebenfalls merklich beeinflussen. Dieses Maß ist nützlich, um die Abfragen zu finden, die die Antwortzeit der Anwendung am meisten beeinträchtigen oder den Server am stärksten belasten, es verrät Ihnen aber nicht, ob die tatsächliche Ausführungszeit für eine Abfrage mit einer bestimmten Komplexität vernünftig ist. (Die Ausführungszeit kann sowohl das Symptom als auch die Ursache von Problemen sein, und es ist nicht unbedingt klar, welcher Fall zutrifft.)
Untersuchte Zeilen und zurückgelieferte Zeilen Es bietet sich an, beim Analysieren von Abfragen an die Anzahl der untersuchten Zeilen zu denken, weil man anhand dessen feststellen kann, wie effizient die Abfrage die Daten ermittelt, die Sie benötigen. Doch genau wie bei der Ausführungszeit handelt es sich auch hier nicht um ein perfektes Maß, um schlechte Abfragen zu finden. Nicht alle Zeilenzugriffe sind gleich. Kürzere Zeilen lassen sich schneller abfragen, und das Beziehen von Zeilen aus dem Speicher geht viel schneller als das Lesen von der Festplatte. Idealerweise wäre die Anzahl der untersuchten Zeilen identisch mit der Anzahl der zurückgelieferten Zeilen. In der Praxis ist das aber kaum möglich. Wenn z.B. Zeilen mithilfe von Joins konstruiert werden, dann muss zum Generieren einer Zeile in der Ergebnismenge jeweils auf mehrere Zeilen zugegriffen werden. Das Verhältnis von untersuchten Zeilen zu zurückgelieferten Zeilen ist normalerweise klein – es liegt etwa zwischen 1:1 und 10:1 –, kann manchmal aber auch um Größenordnungen größer sein.
Untersuchte Zeilen und Zugriffsarten Wenn Sie über die Kosten für eine Abfrage nachdenken, dann sollten Sie auch die Kosten zum Suchen einer einzelnen Zeile in einer Tabelle in Betracht ziehen. MySQL kennt verschiedene Zugriffsmethoden, um eine Zeile zuzugreifen und zurückzuliefern. Manche erfordern das Untersuchen vieler Zeilen, andere wiederum können das Ergebnis generieren, ohne überhaupt eine Zeile zu untersuchen. Die Zugriffsmethode(n) finden Sie in der type-Spalte der EXPLAIN-Ausgabe. Die Zugriffsarten reichen von vollständigen Tabellenscans bis zu Indexscans, Bereichsscans, UniqueIndex-Suchen und Konstanten. Jede Art ist schneller als die jeweils vorhergehende, da entsprechend weniger Daten gelesen werden müssen. Sie müssen sich die Zugriffsarten nicht merken, sollten jedoch die allgemeinen Konzepte verstehen, die sich hinter dem Scannen einer Tabelle, dem Scannen eines Index, Bereichszugriffen und den Zugriffen auf einzelne Werte verbergen. Wenn Sie keine gute Zugriffsart bekommen, dann lösen Sie dieses Problem am besten, indem Sie einen passenden Index hinzufügen. Wir sind im vorangegangenen Kapitel ausführlich auf die Indizierung eingegangen, jetzt erkennen Sie vermutlich auch, weshalb Indizes für die Abfrageoptimierung so wichtig sind. Indizes erlauben es MySQL, Zeilen mit einer effizienteren Zugriffsart zu finden, die weniger Daten untersucht. 166 | Kapitel 4: Optimierung der Abfrageleistung
Schauen wir uns z.B. eine einfache Abfrage in der Sakila-Beispieldatenbank an: mysql> SELECT * FROM sakila.film_actor WHERE film_id = 1;
Diese Abfrage liefert 10 Zeilen zurück. EXPLAIN zeigt, dass MySQL die Zugriffsart ref im idx_fk_film_id-Index einsetzt, um die Abfrage auszuführen: mysql> EXPLAIN SELECT * FROM sakila.film_actor WHERE film_id = 1\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: film_actor type: ref possible_keys: idx_fk_film_id key: idx_fk_film_id key_len: 2 ref: const rows: 10 Extra:
EXPLAIN gibt an, dass MySQL geschätzt hat, es müsste nur auf 10 Zeilen zugreifen. Mit anderen Worten: Der Abfrageoptimierer wusste, dass die gewählte Abfrageart die Abfrage effizient beantworten konnte. Was würde passieren, wenn es keinen passenden Index für die Abfrage gäbe? MySQL müsste eine weniger optimale Abfrageart einsetzen, wie wir leicht sehen können, wenn wir den Index weglassen und die Abfrage erneut ausführen: mysql> ALTER TABLE sakila.film_actor DROP FOREIGN KEY fk_film_actor_film; mysql> ALTER TABLE sakila.film_actor DROP KEY idx_fk_film_id; mysql> EXPLAIN SELECT * FROM sakila.film_actor WHERE film_id = 1\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: film_actor type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 5073 Extra: Using where
Wie vorherzusehen war, wird als Zugriffsart nun ein vollständiger Tabellenscan (ALL) angegeben, und MySQL schätzt, dass es 5.073 Zeilen untersuchen muss, um die Abfrage zu bedienen. Das »Using where« in der Extra-Spalte zeigt, dass der MySQL-Server die WHERE-Klausel benutzt, um Zeilen zu verwerfen, nachdem die Storage-Engine sie gelesen hat. Im Allgemeinen kann MySQL eine WHERE-Klausel auf drei Arten anwenden (von der besten zur schlechten): • Es wendet die Bedingungen auf die Index-Lookup-Operation an, um nicht passende Zeilen zu eliminieren. Dies geschieht auf der Storage-Engine-Ebene.
Grundlagen langsamer Abfragen: Datenzugriff optimieren | 167
• Es benutzt einen abdeckenden Index (»Using index« in der Extra-Spalte), um Zeilenzugriffe zu vermeiden, und filtert nicht passende Zeilen aus, nachdem es die einzelnen Ergebnisse aus dem Index bekommen hat. Dies geschieht auf der Serverebene, verlangt aber nicht das Lesen von Zeilen aus der Tabelle. • Es holt Zeilen aus der Tabelle und filtert dann nicht passende Zeilen aus (»Using where« in der Extra-Spalte). Dies geschieht auf der Serverebene und verlangt, dass der Server Zeilen aus der Tabelle liest, bevor er sie ausfiltern kann. Dieses Beispiel verdeutlicht, wie wichtig es ist, gute Indizes zu haben. Gute Indizes helfen Ihren Abfragen, eine gute Zugriffsart zu wählen und nur die benötigten Zeilen zu untersuchen. Allerdings bedeutet das Hinzufügen eines Index nicht immer, dass MySQL auf die gleiche Anzahl an Zeilen zugreift und diese zurückliefert. Hier ist z.B. eine Abfrage, die die Aggregatfunktion COUNT( ) verwendet:2 mysql> SELECT actor_id, COUNT(*) FROM sakila.film_actor GROUP BY actor_id;
Hier werden nur 200 Zeilen zurückgeliefert, allerdings müssen Tausende von Zeilen gelesen werden, um die Ergebnismenge zusammenzustellen. Ein Index kann die Anzahl der zu untersuchenden Zeilen für eine solche Abfrage nicht verringern. Leider verrät MySQL Ihnen nicht, wie viele Zeilen, auf die es zugegriffen hat, zum Erstellen der Ergebnismenge benutzt wurden; es gibt lediglich die Gesamtzahl der zugegriffenen Zeilen an. Viele dieser Zeilen könnten mit einer WHERE-Klausel eliminiert werden und würden nichts zur Ergebnismenge beitragen. Im gezeigten Beispiel griff die Abfrage nach dem Entfernen des Index in sakila.film_actor auf jede Zeile in der Tabelle zu, und die WHERE-Klausel verwarf alle bis auf 10 von ihnen. Die Ergebnismenge wurde nur aus den zehn verbleibenden Zeilen generiert. Um zu verstehen, auf wie viele Zeilen der Server zugreift und wie viele er tatsächlich benutzt, muss man über die Abfrage nachdenken. Falls Sie feststellen, dass eine große Anzahl von Zeilen untersucht wurde, um relativ wenige Zeilen im Ergebnis auszuliefern, dann testen Sie diese raffinierteren Ansätze: • Benutzen Sie abdeckende Indizes, die die Daten speichern, damit die Storage-Engine nicht vollständige Zeilen holen muss. (Wir haben das im vorherigen Kapitel besprochen.) • Ändern Sie das Schema. Benutzen Sie z.B. Summary-Tabellen (das wurde im vorherigen Kapitel beschrieben). • Schreiben Sie eine komplizierte Abfrage so um, dass der MySQL-Optimierer sie optimal ausführen kann. (Darauf kommen wir weiter hinten in diesem Kapitel zu sprechen.)
2 Siehe »COUNT( )-Abfragen optimieren« auf Seite 202 für mehr Informationen zu diesem Thema.
168 | Kapitel 4: Optimierung der Abfrageleistung
Methoden zum Umstrukturieren von Abfragen Wenn Sie problematische Abfragen optimieren, sollte Ihr Ziel darin bestehen, alternative Möglichkeiten zu finden, um das gewünschte Ergebnis zu erhalten – das bedeutet aber nicht unbedingt, dass Sie von MySQL die gleiche Ergebnismenge zurückbekommen. Manchmal kann man Abfragen in äquivalente Formen umwandeln und eine bessere Leistung erzielen. Sie sollten allerdings auch darüber nachdenken, die Abfrage so umzuschreiben, dass Sie andere Ergebnisse bekommen, falls das einen Effizienzvorteil bietet. Sie sollten schließlich auch in der Lage sein, die gleiche Arbeit zu verrichten, indem Sie sowohl den Anwendungscode als auch die Abfrage ändern. In diesem Abschnitt erläutern wir Techniken, die Ihnen dabei helfen können, einen großen Bereich an Abfragen umzustrukturieren, und zeigen Ihnen, wann Sie die einzelnen Techniken einsetzen.
Komplexe Abfragen oder viele Abfragen? Eine wichtige Frage beim Entwurf von Abfragen lautet, ob es besser ist, eine komplexe Abfrage in mehrere einfachere Abfragen aufzuteilen. Der traditionelle Ansatz beim Datenbankentwurf verfolgt eine Philosophie, nach der so viel Arbeit wie möglich mit möglichst wenigen Abfragen erledigt werden sollte. Historisch gesehen war dieser Ansatz wegen der Kosten für die Netzwerkkommunikation und dem Overhead bei der Analyse der Abfragen und der verschiedenen Stadien der Optimierung besser. Dieser Rat hat allerdings für MySQL keine allzu große Bedeutung, da es bereits von sich aus den Auf- und Abbau von Verbindungen sehr effizient erledigt und schnell auf kleine und einfache Abfragen reagiert. Moderne Netzwerke sind darüber hinaus deutlich schneller als früher, wodurch sich die Netzwerklatenz verringert. MySQL kann auf ganz normaler Serverhardware mehr als 50.000 einfache Abfragen pro Sekunde ausführen. In einem Gigabit-Netzwerk kommt es auf mehr als 2.000 Abfragen pro Sekunde von einem einzelnen Partner, so dass es im Allgemeinen kein großes Problem mehr darstellt, mehrere Abfragen gleichzeitig abzufertigen. Die Verbindungsantwort ist allerdings im Vergleich zu der Anzahl an Zeilen, die MySQL intern pro Sekunde verschieben kann (die bei Daten im Speicher in Millionen pro Sekunde gerechnet werden), immer noch verhältnismäßig langsam. Es ist also im Großen und Ganzen eine gute Idee, so wenige Abfragen wie möglich zu verwenden. Manchmal allerdings können Sie eine Abfrage effizienter gestalten, indem Sie sie auseinandernehmen und einige einfachere Abfragen anstelle einer komplexen Abfrage ausführen. Haben Sie keine Angst davor; wägen Sie den Aufwand ab, und wählen Sie die Strategie, die weniger Arbeit verursacht. Wir zeigen etwas weiter hinten in diesem Kapitel einige Beispiele für diese Technik. Das heißt also, ein verbreiteter Fehler beim Anwendungsentwurf ist die Verwendung zu vieler Abfragen. So führen z.B. manche Anwendungen 10 einzeilige Abfragen aus, um Daten aus einer Tabelle zu beziehen, wenn sie auch eine einzige zehnzeilige Abfrage benutzen könnten. Uns sind sogar schon Anwendungen begegnet, die jede Spalte einzeln geholt haben, wobei jede Zeile viele Male abgefragt wurde! Methoden zum Umstrukturieren von Abfragen | 169
Eine Abfrage zerlegen Eine andere Möglichkeit, eine Abfrage zu zerlegen, geht nach dem Prinzip »teile und herrsche« vor, wobei die Abfrage prinzipiell gleich bleibt, aber in kleineren »Bröckchen« ausgeführt wird, die weniger Zeilen gleichzeitig beeinflussen. Ein großartiges Beispiel ist das Beseitigen alter Daten. Periodisch durchgeführte Löschjobs müssen möglicherweise eine Menge Daten entfernen. Wird dies innerhalb einer umfangreichen Abfrage erledigt, werden vielleicht viele Zeilen über einen langen Zeitraum gesperrt, Transaktions-Logs gefüllt, Ressourcen verschwendet und kleine Abfragen blockiert, die nicht unterbrochen werden dürfen. Nimmt man die DELETE-Anweisung aus der Abfrage heraus und verwendet man mittelgroße Abfragen, kann die Leistung deutlich verbessert werden. Außerdem reduziert sich die Verzögerung bei einer Replikation der Abfrage. Anstatt z.B. diesen Koloss von Abfrage auszuführen: mysql> DELETE FROM messages WHERE created < DATE_SUB(NOW( ),INTERVAL 3 MONTH);
könnten Sie etwa den folgenden Pseudocode einsetzen: rows_affected = 0 do { rows_affected = do_query( "DELETE FROM messages WHERE created < DATE_SUB(NOW( ),INTERVAL 3 MONTH) LIMIT 10000") } while rows_affected > 0
Das gleichzeitige Löschen von 10.000 Zeilen ist als Aufgabe typischerweise groß genug, um jede Abfrage effizient zu machen, und gleichzeitig kurz genug, um die Auswirkungen auf den Server zu minimieren3 (transaktionsfähige Storage-Engines könnten von kleineren Transaktionen profitieren). Es ist vielleicht außerdem ganz günstig, wenn man zwischen den DELETE-Anweisungen eine gewisse Sleep-Zeit einfügt, damit die Last über die Zeit verteilt wird und die Haltedauer für die Sperren reduziert wird.
Join-Zerlegung Viele Hochleistungswebsites setzen Join-Zerlegung ein. Sie können einen Join zerlegen, indem Sie mehrere Eintabellenabfragen anstelle eines Mehrtabellen-Joins ausführen und dann den Join in der Anwendung erledigen. Anstatt dieser einzelnen Abfrage: mysql> SELECT * FROM tag -> JOIN tag_post ON tag_post.tag_id=tag.id -> JOIN post ON tag_post.post_id=post.id -> WHERE tag.tag='mysql';
könnten Sie z.B. diese Abfragen ausführen: mysql> SELECT * FROM mysql> SELECT * FROM mysql> SELECT * FROM
tag WHERE tag='mysql'; tag_post WHERE tag_id=1234; post WHERE post.id in (123,456,567,9098,8904);
3 Maatkits mk-archiver-Programm erleichtert diese Art von Jobs.
170 | Kapitel 4: Optimierung der Abfrageleistung
Auf den ersten Blick sieht das vielleicht verschwenderisch aus, da Sie die Anzahl der Abfragen erhöht haben, ohne dass Sie etwas zurückbekommen. Eine solche Restrukturierung kann allerdings beträchtliche Leistungsvorteile bringen: • Das Caching kann effizienter sein. Viele Anwendungen legen »Objekte« im Cache ab, die direkt auf Tabellen abgebildet werden. Falls in diesem Beispiel das Objekt mit dem Tag mysql bereits im Cache vorliegt, kann die Anwendung die erste Abfrage überspringen. Finden Sie Nachrichten mit der id 123, 567 oder 9098 im Cache, können Sie sie von der IN( )-Liste entfernen. Auch der Abfrage-Cache könnte etwas von dieser Strategie haben. Falls sich nur eine der Tabellen häufig ändert, kann das Zerlegen eines Join die Anzahl der Cache-Ausfälle verringern. • Bei MyISAM-Tabellen werden Tabellen-Locks effizienter eingesetzt, wenn nur eine Abfrage pro Tabelle ausgeführt wird: Die Abfragen sperren die Tabellen individuell und relativ kurz, anstatt sie alle über einen längeren Zeitraum zu sperren. • Das Ausführen von Joins in der Anwendung macht es leichter, die Datenbank zu skalieren, indem man Tabellen auf unterschiedliche Server legt. • Die Abfragen selbst können effizienter sein. In diesem Beispiel erlaubt der Einsatz einer IN( )-Liste anstelle eines Joins es MySQL, Zeilen-IDs zu sortieren und Zeilen optimaler abzurufen, als es mit einem Join möglich wäre. Später mehr dazu. • Sie können die redundanten Zeilenzugriffe reduzieren. Das Ausführen eines Joins in der Anwendung bedeutet, dass Sie jede Zeile nur einmal abrufen, während ein Join in der Abfrage im Prinzip eine Denormalisierung ist, die wiederholt auf die gleichen Daten zugreifen könnte. Aus dem gleichen Grund könnte eine solche Umstrukturierung den Gesamtnetzwerkverkehr und die Speicherbelegung verringern. • Bis zu einem gewissen Grad können Sie diese Technik als eine manuelle Implementierung eines Hash-Joins betrachten statt als den geschachtelten Schleifenalgorithmus, den MySQL einsetzt, um einen Join auszuführen. Ein Hash-Join ist möglicherweise effizienter. (Wir kommen weiter hinten in diesem Kapitel auf die Join-Strategie von MySQL zurück.)
Zusammenfassung: Wann Anwendungs-Joins effizienter sind Das Ausführen von Joins in der Anwendung könnte effizienter sein, wenn:
• • • • •
Sie viele Daten aus früheren Abfragen im Cache speichern und wiederverwenden Sie mehrere MyISAM-Tabellen benutzen Sie Daten über mehrere Server verteilen Sie Joins in großen Tabellen durch IN( )-Listen ersetzen Ein Join sich mehrmals auf die gleiche Tabelle bezieht
Methoden zum Umstrukturieren von Abfragen | 171
Grundlagen der Abfrageverarbeitung Falls Sie von Ihrem MySQL-Server Spitzenleistungen erwarten, sollten Sie sich am besten darauf konzentrieren, zu lernen, wie MySQL Abfragen optimiert und ausführt. Sobald Sie das verstanden haben, besteht die Abfrageoptimierung zum Großteil darin, sie von den Prinzipien abzuleiten. Sie wird dadurch zu einem sehr logischen Vorgang. Dieser Abschnitt geht davon aus, dass Sie Kapitel 1 gelesen haben, wo die Grundlagen für das Verständnis der Abfrageverarbeitung bei MySQL gelegt werden.
Abbildung 4-1 zeigt, wie MySQL im Allgemeinen Abfragen ausführt. MySQL-Server Client/ServerProtokoll
SQL Ergebnis
AbfrageCache
Parser
Präprozessor
Client
Parser-Baum
Abfrageoptimierer Ergebnis Abfrageausführungsplan
Sprint-Review Abfrageausführungs-Engine API-Aufrufe Storage-Engines MyISAM InnoDB usw....
Abbildung 4-1: Ausführungspfad einer Abfrage
172 | Kapitel 4: Optimierung der Abfrageleistung
Daten
Anhand der Illustration können Sie erkennen, was passiert, wenn Sie MySQL eine Abfrage schicken: 1. Der Client sendet die SQL-Anweisung an den Server. 2. Der Server prüft den Abfrage-Cache. Wenn es einen Treffer gibt, liefert er das
gespeicherte Ergebnis aus dem Cache; ansonsten übergibt er die SQL-Anweisung an den nächsten Schritt. 3. Der Server analysiert, verarbeitet und optimiert das SQL in einem Abfrageausfüh-
rungsplan. 4. Die Engine zur Abfrageausführung führt den Plan aus, indem sie Aufrufe an die API
der Storage-Engine startet. 5. Der Server sendet das Ergebnis an den Client zurück.
Es handelt sich hier um jeweils recht komplexe Schritte, auf die wir in den folgenden Abschnitten eingehen. Wir erläutern außerdem, in welchen Zuständen sich die Abfrage während der einzelnen Schritte befinden wird. Der Vorgang der Abfrageoptimierung ist besonders komplex, und es ist wichtig, dass Sie ihn verstehen.
Das MySQL-Client/Server-Protokoll Es ist zwar nicht notwendig, dass Sie die Interna des Client/Server-Protokolls von MySQL verstehen, Sie sollten aber wissen, wie es auf einer höheren Ebene funktioniert. Das Protokoll arbeitet im Halbduplex-Modus. Das bedeutet, dass der MySQL-Server zu einem bestimmten Zeitpunkt Nachrichten entweder senden oder empfangen kann, aber nicht beides. Es bedeutet außerdem, dass es keine Möglichkeit gibt, eine Nachricht abzukürzen. Dieses Protokoll macht die MySQL-Kommunikation einfach und schnell, beschränkt sie aber auch auf gewisse Weise. Zum einen gibt es keine Flusskontrolle; sobald die eine Seite eine Nachricht sendet, muss die andere Seite die gesamte Nachricht entgegennehmen, bevor sie antworten kann. Es ist, als würde man einen Ball hin- und herwerfen: Nur eine Seite hat zu einem Zeitpunkt den Ball, und Sie können den Ball nur dann werfen (eine Nachricht senden), wenn Sie ihn haben. Der Client sendet eine Abfrage als einzelnes Datenpaket an den Server. Aus diesem Grund ist bei großen Abfragen die Konfigurationsvariable max_packet_size so wichtig.4 Nachdem der Client die Abfrage gesendet hat, besitzt er quasi den Ball nicht mehr, er kann jetzt nur noch auf Ergebnisse warten. Im Gegensatz dazu besteht die Antwort vom Server normalerweise aus vielen Datenpaketen. Wenn der Server antwortet, muss der Client die gesamte Ergebnismenge entgegennehmen. Er kann nicht einfach ein paar Zeilen abrufen und dann den Server auffordern, ihn mit dem Rest nicht mehr zu belästigen. Benötigt der Client nur die ersten Zeilen, die zurückgeliefert werden, muss er entweder darauf warten, bis alle Pakete des Servers ange4 Wenn die Abfrage zu groß ist, lehnt der Server es ab, weitere Daten zu empfangen, und löst einen Fehler aus.
Grundlagen der Abfrageverarbeitung | 173
kommen sind, und dann die nicht mehr benötigten Zeilen verwerfen, oder er muss die Verbindung unsanft unterbrechen. Keine der beiden Varianten ist besonders gut, weshalb passende LIMIT-Klauseln so wichtig sind. Sie können es sich auch so vorstellen: Wenn ein Client Zeilen vom Server abruft, dann glaubt er, dass er sie zieht. In Wirklichkeit schiebt der MySQL-Server die Zeilen zum Client, nachdem er sie generiert hat. Der Client empfängt lediglich die geschobenen Zeilen; er hat keine Möglichkeit, den Server aufzufordern, das Senden der Zeilen zu stoppen. Der Client wird förmlich überschwemmt. Die meisten Bibliotheken, die eine Verbindung zu MySQL herstellen, erlauben es Ihnen entweder, die gesamte Ergebnismenge zu holen und im Speicher zu puffern, oder holen die einzelnen Zeilen, wenn Sie sie brauchen. Standardmäßig wird im Allgemeinen das gesamte Ergebnis geholt und im Speicher gepuffert. Das ist wichtig, weil der MySQL-Server erst dann alle Sperren und weiteren Ressourcen, die von der Abfrage benötigt wurden, freigibt, wenn er alle Zeilen geholt hat. Die Abfrage bleibt im »Sending data«Zustand (erläutert in »Abfragezustände« auf Seite 175). Wenn die Client-Bibliothek die Ergebnisse alle auf einmal holt, verringert sie die Arbeitsmenge, die der Server verrichten muss: Der Server kann die Abfrage so schnell wie möglich beenden und hinter sich aufräumen. Die meisten Client-Bibliotheken erlauben es Ihnen, die Ergebnismenge so zu behandeln, als würden Sie sie vom Server holen, obwohl Sie sie eigentlich aus dem Puffer im Speicher der Bibliothek beziehen. Meist funktioniert das auch ganz gut, es eignet sich aber nicht besonders gut für riesige Ergebnismengen, bei denen das Holen schon lange dauert und die entsprechend viel Speicher beanspruchen. Sie brauchen weniger Speicher und können schneller mit dem Ergebnis arbeiten, wenn Sie die Bibliothek anweisen, das Ergebnis nicht zu puffern. Der Nachteil dieses Vorgehens besteht darin, dass die Sperren und die anderen Ressourcen auf dem Server offen bleiben, während die Anwendung mit der Bibliothek interagiert.5 Schauen wir uns ein Beispiel mit PHP an. So würde man normalerweise MySQL aus PHP heraus abfragen:
Der Code scheint anzudeuten, dass Sie die Zeilen nur dann holen, wenn Sie sie benötigen, nämlich in der while-Schleife. Tatsächlich packt der Code das gesamte Ergebnis mit dem Funktionsaufruf mysql_query( ) in einen Puffer. Die while-Schleife durchläuft ein-
5 Sie können das mit SQL_BUFFER_RESULT umgehen, wie Sie gleich sehen werden.
174 | Kapitel 4: Optimierung der Abfrageleistung
fach den Puffer. Im Gegensatz dazu puffert der folgende Code die Ergebnisse nicht, da er mysql_unbuffered_query( ) anstelle von mysql_query( ) verwendet:
Programmiersprachen haben verschiedene Methoden, um die Pufferung außer Kraft zu setzen. So verlangt z.B. der Perl-Treiber DBD::mysql, dass Sie das mysql_use_result-Attribut der C-Client-Bibliothek angeben (Vorgabe ist mysql_buffer_result). Hier ein Beispiel: #!/usr/bin/perl use DBI; my $dbh = DBI->connect('DBI:mysql:;host=localhost', 'user', 'p4ssword'); my $sth = $dbh->prepare('SELECT * FROM HUGE_TABLE', { mysql_use_result => 1 }); $sth->execute( ); while ( my $row = $sth->fetchrow_array( ) ) { # Tun Sie etwas mit dem Ergebnis }
Beachten Sie, dass der Aufruf zu prepare( ) angegeben hat, das Ergebnis zu »benutzen« (use) anstatt es zu »puffern« (buffer). Sie können das auch beim Verbindungsaufbau angeben, wodurch jede Anweisung ungepuffert bleibt: my $dbh = DBI->connect('DBI:mysql:;mysql_use_result=1', 'user', 'p4ssword');
Abfragezustände Jede MySQL-Verbindung oder jeder Thread besitzt einen Zustand, der anzeigt, was sie bzw. er zu einem bestimmten Zeitpunkt tut. Es gibt verschiedene Möglichkeiten, diese Zustände anzuschauen, am einfachsten geht es mit dem Befehl SHOW FULL PROCESSLIST (die Zustände stehen in der Command-Spalte). Während der Lebensdauer einer Abfrage ändert sich ihr Zustand viele Male, und es gibt Dutzende von Zuständen. Das MySQL-Handbuch ist die verbindliche Informationsquelle für alle Zustände, wir wollen aber trotzdem hier einige aufführen und erläutern, was sie bedeuten: Sleep
Der Thread wartet auf eine neue Abfrage vom Client. Query
Der Thread führt entweder die Abfrage aus oder schickt das Ergebnis zurück an den Client. Locked
Der Thread wartet darauf, dass ein Tabellen-Lock auf Serverebene gewährt wird. Sperren, die durch die Storage-Engine implementiert werden, wie etwa Row-Locks von InnoDB, veranlassen den Thread nicht dazu, in den Zustand Locked überzugehen.
Grundlagen der Abfrageverarbeitung | 175
Analyzing und statistics
Der Thread prüft die Storage-Engine-Statistiken und optimiert die Abfrage. Copying to tmp table [on disk]
Der Thread verarbeitet die Abfrage und kopiert die Ergebnisse in eine temporäre Tabelle, wahrscheinlich für ein GROUP BY, ein Filesort oder um ein UNION zu bedienen. Wenn der Zustand mit »on disk« endet, konvertiert MySQL eine im Speicher befindliche Tabelle in eine auf der Festplatte befindliche Tabelle. Sorting result
Der Thread sortiert eine Ergebnismenge. Sending data
Dies kann mehrere Dinge bedeuten: Der Thread könnte Daten zwischen Stadien der Abfrage verschicken, eine Ergebnismenge generieren oder die Ergebnismenge an den Client zurücksenden. Es ist ganz hilfreich, wenigstens die grundlegenden Zustände zu kennen, damit Sie eine Vorstellung davon bekommen können, »wer den Ball für die Abfrage hat«. Bei sehr ausgelasteten Servern könnte ein ungewöhnlicher oder normalerweise kurzer Zustand, wie etwa statistics, anfangen, einen wesentlichen Anteil der Zeit zu beanspruchen. Das deutet üblicherweise darauf hin, dass etwas nicht in Ordnung ist.
Der Abfrage-Cache Bevor MySQL überhaupt eine Abfrage analysiert, sucht es im Abfrage-Cache nach ihr, falls der Cache aktiviert ist. Bei dieser Operation handelt es sich um eine Hash-Suche unter Beachtung der Groß- und Kleinschreibung. Wenn die Abfrage sich auch nur um ein Byte von einer ähnlichen Abfrage im Cache unterscheidet, gilt dies nicht als Treffer, und die Abfrageverarbeitung geht ins nächste Stadium über. Findet MySQL dagegen eine passende Abfrage im Abfrage-Cache, muss es die Rechte überprüfen, bevor es die im Cache gespeicherte Abfrage zurückliefert. Das ist möglich, ohne die Abfrage zu analysieren, weil MySQL zusammen mit der Abfrage Tabelleninformationen im Cache speichert. Wenn die Rechte in Ordnung sind, fragt MySQL das gespeicherte Ergebnis aus dem Abfrage-Cache ab und sendet es an den Client. Dadurch wird jedes weitere Stadium in der Abfrageausführung übergangen. Die Abfrage wird niemals analysiert, optimiert oder ausgeführt. Sie erfahren in Kapitel 5 mehr über den Abfrage-Cache.
Die Abfrageoptimierung Der nächste Schritt im Leben einer Abfrage wandelt eine SQL-Abfrage in einen Ausführungsplan für die Abfrageausführungs-Engine um. Dieser Schritt besteht aus mehreren Teilschritten: Analyse, Vorverarbeitung und Optimierung. Fehler (z.B. Syntaxfehler) können an jeder Stelle in diesem Vorgang aufgedeckt werden. Wir versuchen hier nicht, die MySQL-Interna zu dokumentieren, weshalb wir uns hier einige Freiheiten nehmen.
176 | Kapitel 4: Optimierung der Abfrageleistung
So beschreiben wir etwa die Schritte einzeln, obwohl sie aus Gründen der Effizienz oftmals ganz oder teilweise kombiniert werden. Wir wollen ganz einfach, dass Sie verstehen, wie MySQL Abfragen ausführt, damit Sie in der Lage sind, bessere Abfragen zu schreiben.
Der Parser und der Präprozessor Zuerst unterteilt der MySQL-Parser die Abfrage in Token und erzeugt aus ihnen einen »Parse-Baum«. Der Parser verwendet die SQL-Grammatik von MySQL, um die Abfrage zu interpretieren und zu validieren. Er stellt z.B. sicher, dass die Abfrage gültig (valide) ist und in der richtigen Reihenfolge vorliegt, und prüft auf Fehler wie etwa quotierte Strings, die nicht terminiert wurden. Der Präprozessor überprüft dann den resultierenden Parse-Baum auf zusätzliche Semantiken, die der Parser nicht auflösen kann. So schaut er z.B. nach, ob Tabellen und Spalten existieren, und löst Namen und Aliase auf, um sicherzugehen, dass die Spaltenreferenzen nicht mehrdeutig sind. Als Nächstes prüft der Präprozessor die Rechte. Das geht normalerweise sehr schnell, es sei denn, Ihr Server verfügt über sehr viele Rechte. (In Kapitel 12 erfahren Sie mehr über Rechte und Sicherheit.)
Der Abfrageoptimierer Der Parse-Baum ist jetzt gültig und wartet darauf, vom Optimierer in einen Ausführungsplan umgewandelt zu werden. Eine Abfrage kann oft auf verschiedene Weisen ausgeführt werden und immer das gleiche Ergebnis erzeugen. Die Aufgabe des Optimierers besteht darin, die beste Möglichkeit zu finden. MySQL verwendet einen kostenbasierten Optimierer. Dieser versucht, die Kosten für die verschiedenen Ausführungspläne vorherzusagen und den am wenigsten teuren Ausführungsplan zu wählen. Die Einheit für die Kosten ist ein einzelner zufälliger Lesevorgang für eine vier Kilobyte große Datenseite. Sie können feststellen, wie teuer der Optimierer eine Abfrage einschätzt, indem Sie die Abfrage ausführen und dann die Session-Variable Last_query_cost auswerten: mysql> SELECT SQL_NO_CACHE COUNT(*) FROM sakila.film_actor; +----------+ | count(*) | +----------+ | 5462 | +----------+ mysql> SHOW STATUS LIKE 'last_query_cost'; +-----------------+-------------+ | Variable_name | Value | +-----------------+-------------+ | Last_query_cost | 1040.599000 | +-----------------+-------------+
Grundlagen der Abfrageverarbeitung | 177
Dieses Ergebnis bedeutet, dass der Optimierer geschätzt hat, es würde etwa 1.040 zufällige Lesezugriffe auf Datenseiten erfordern, um die Abfrage auszuführen. Er baut seine Schätzung auf Statistiken auf: der Anzahl der Seiten pro Tabelle oder Index, der Kardinalität (Anzahl der Einzelwerte) der Indizes, der Länge der Zeilen und Schlüssel sowie der Schlüsselverteilung. Der Optimierer bezieht die Auswirkungen irgendwelcher Caches nicht in seine Schätzung ein, sondern geht davon aus, dass jeder Lesevorgang zu einem Festplattenzugriff führt. Möglicherweise wählt der Optimierer nicht immer den besten Plan. Das kann viele Gründe haben: • Die Statistiken könnten falsch sein. Der Server verlässt sich für die Statistiken auf die Storage-Engines. Sie können von außerordentlich korrekt bis zu völlig falsch reichen. So liefert z.B. die InnoDB-Storage-Engine aufgrund ihrer MVCC-Architektur keine exakten Statistiken über die Anzahl der Zeilen in einer Tabelle. • Das Kostenmaß ist nicht genau äquivalent zu den wahren Kosten für das Ausführen einer Abfrage. Das heißt, selbst wenn die Statistiken exakt sind, kann die Abfrage teurer oder weniger teuer sein, als die Schätzung von MySQL angibt. Ein Plan, der mehr Seiten liest, könnte in einigen Fällen dennoch billiger ausfallen, etwa wenn die Lesevorgänge sequenziell erfolgen, die Plattenzugriffe also schneller sind, oder wenn die Seiten bereits im Speicher vorliegen. • Die Ansichten von MySQL über ein Optimum entsprechen möglicherweise nicht Ihren Vorstellungen. Wahrscheinlich wollen Sie die schnellste Ausführungszeit haben; MySQL dagegen versteht »schnell« nicht, es meint »Kosten«. Und wie wir gesehen haben, ist das Feststellen der Kosten keine exakte Wissenschaft. • MySQL zieht keine anderen Abfragen in Betracht, die parallel ablaufen und damit beeinflussen können, wie schnell die Abfrage ausgeführt wird. • MySQL führt nicht immer eine kostenbasierte Optimierung durch. Manchmal hält es sich einfach nur an die Regeln, wie etwa: »Wenn es eine Volltext-MATCH( )-Klausel gibt, verwende einen FULLTEXT-Index, so es einen gibt.« Das tut es auch dann, wenn es eigentlich schneller wäre, einen anderen Index einzusetzen und eine Nicht-FULLTEXT-Abfrage mit einer WHERE-Klausel durchzuführen. • Der Optimierer zieht die Kosten von Operationen, die nicht seiner Kontrolle unterliegen, nicht in Betracht, wie etwa das Ausführen gespeicherter benutzerdefinierter Funktionen. • Wie wir später sehen werden, kann der Optimierer nicht immer jeden möglichen Ausführungsplan abschätzen und verpasst deswegen manchmal einen optimalen Plan. Der Abfrageoptimierer von MySQL ist ein ausgesprochen komplexes Stück Software und benutzt viele Optimierungen, um die Abfrage in einen Ausführungsplan umzuwandeln. Es gibt zwei grundlegende Arten von Optimierungen, die wir als statisch und dynamisch bezeichnen. Statische Optimierungen können ausgeführt werden, indem einfach der
178 | Kapitel 4: Optimierung der Abfrageleistung
Parse-Baum untersucht wird. So kann z.B. der Optimierer die WHERE-Klausel in eine äquivalente Form umwandeln, indem er algebraische Regeln anwendet. Statische Optimierungen sind unabhängig von Werten, wie etwa dem Wert einer Konstanten in einer WHERE-Klausel. Sie können einmal durchgeführt werden und sind immer gültig, selbst wenn die Abfrage mit anderen Werten noch einmal ausgeführt wird. Stellen Sie sie sich einfach als »Optimierungen zur Compile-Zeit« vor. Im Gegensatz dazu beruhen dynamische Optimierungen auf dem Kontext und können von vielen Faktoren abhängen, wie etwa vom Wert in einer WHERE-Klausel oder der Anzahl der Zeilen in einem Index. Sie müssen jedes Mal neu bewertet werden, wenn die Abfrage ausgeführt wird. Stellen Sie sie sich als »Laufzeitoptimierungen« vor. Der Unterschied ist wichtig, wenn vorbereitete Anweisungen oder gespeicherte Prozeduren ausgeführt werden. MySQL kann statische Optimierungen einmal durchführen, muss aber dynamische Optimierungen jedes Mal neu bewerten, wenn es eine Abfrage ausführt. Manchmal optimiert es sogar die Abfrage neu, wenn es sie ausführt.6 Dies sind einige Arten von Optimierungen, die MySQL kennt: Umsortieren von Joins Tabellen müssen nicht immer in der Reihenfolge zusammengeführt werden, die Sie in der Abfrage angeben. Das Festlegen der besten Join-Reihenfolge ist eine wichtige Optimierung. Wir erläutern sie in »Der Join-Optimierer« auf Seite 186 genauer. OUTER JOINs in INNER JOINs umwandeln Ein OUTER JOIN muss nicht unbedingt als OUTER JOIN ausgeführt werden. Manche Faktoren, wie etwa die WHERE-Klausel und das Tabellenschema können dafür sorgen, dass ein OUTER JOIN eigentlich äquivalent zu einem INNER JOIN ist. MySQL kann das
erkennen und den Join umschreiben, so dass er für eine Umsortierung geeignet ist. Anwenden algebraischer Äquivalenzregeln MySQL wendet algebraische Transformationen an, um Ausdrücke zu vereinfachen und zu kanonisieren. Es kann auch Konstanten zusammenlegen und reduzieren, wodurch unmögliche Constraints und Konstantenbedingungen eliminiert werden. So wird z.B. der Term (5=5 AND a>5) auf a>5 reduziert. Aus (a5 AND b=c AND a=5. Diese Regeln helfen beim Schreiben bedingter Abfragen, auf die wir weiter hinten in diesem Kapitel eingehen. COUNT( )-, MIN( )- und MAX( )-Optimierungen
Indizes und Spalten-Nullability können MySQL oft dabei unterstützen, diese Ausdrücke wegzurationalisieren. Um z.B. den Minimalwert einer Spalte zu ermitteln, die am weitesten links in einem B-Baum-Index steht, kann MySQL einfach die erste Zeile im Index anfordern. Das kann es sogar während der Abfrageoptimierung tun; anschließend behandelt es den Wert für den Rest der Abfrage als Konstante. Um 6 Zum Beispiel bewertet der Bereichstest-Abfrageplan Indizes für jede Zeile in einem JOIN neu. Sie können diesen Abfrageplan sehen, wenn Sie nach »range checked for each record« in der Extra-Spalte in EXPLAIN suchen. Dieser Abfrageplan inkrementiert außerdem die Servervariable Select_full_range_join.
Grundlagen der Abfrageverarbeitung | 179
entsprechend den Maximalwert in einem B-Baum-Index zu finden, liest der Server die letzte Zeile. Wenn der Server diese Optimierung einsetzt, steht »Select tables optimized away« im EXPLAIN-Plan. Das bedeutet tatsächlich, dass der Optimierer die Tabelle aus dem Abfrageplan entfernt und durch eine Konstante ersetzt hat. Ebenso können COUNT(*)-Abfragen ohne WHERE-Klausel in manchen Storage-Engines »wegoptimiert« werden (wie etwa bei MyISAM, wo es in der Tabelle immer einen exakten Zeilenzähler gibt). Näheres erfahren Sie in »COUNT( )-Abfragen optimieren« auf Seite 202. Konstantenausdrücke evaluieren und reduzieren Wenn MySQL entdeckt, dass ein Ausdruck auf eine Konstante reduziert werden kann, dann erledigt es das während der Optimierung. Beispielsweise kann eine benutzerdefinierte Variable in eine Konstante umgewandelt werden, wenn sie nicht in der Abfrage verändert wird. Arithmetische Ausdrücke bilden ein weiteres Beispiel. Vielleicht überraschenderweise kann sogar etwas, das Sie als Abfrage betrachten, während der Optimierungsphase auf eine Konstante reduziert werden. Ein Beispiel ist ein MIN( ) in einem Index. Das kann sogar zu einer Konstantensuche in einem Primärschlüssel oder einem eindeutigen Index erweitert werden. Wenn eine WHEREKlausel eine Konstantenbedingung auf einen solchen Index anwendet, weiß der Optimierer, dass MySQL den Wert am Anfang der Abfrage nachschauen kann. Es behandelt den Wert dann im weiteren Verlauf der Abfrage als Konstante. Hier ist ein Beispiel: mysql> EXPLAIN SELECT film.film_id, film_actor.actor_id -> FROM sakila.film -> INNER JOIN sakila.film_actor USING(film_id) -> WHERE film.film_id = 1; +----+-------------+------------+-------+----------------+-------+------+ | id | select_type | table | type | key | ref | rows | +----+-------------+------------+-------+----------------+-------+------+ | 1 | SIMPLE | film | const | PRIMARY | const | 1 | | 1 | SIMPLE | film_actor | ref | idx_fk_film_id | const | 10 | +----+-------------+------------+-------+----------------+-------+------+
MySQL führt diese Abfrage in zwei Schritten aus, die den zwei Zeilen in der Ausgabe entsprechen. Der erste Schritt besteht darin, die gewünschte Zeile in der filmTabelle zu suchen. Der MySQL-Optimierer weiß, dass es nur eine Zeile gibt, weil sich ein Primärschlüssel in der film_id-Spalte befindet, und hat bereits während der Abfrageoptimierung den Index konsultiert, um festzustellen, wie viele Zeilen er vorfinden wird. Da der Abfrageoptimierer bei der Suche eine bekannte Größe (den Wert in der WHERE-Klausel) verwendet, ist der ref-Typ dieser Tabelle const. Im zweiten Schritt behandelt MySQL die film_id-Spalte aus der Zeile, die im ersten Schritt gefunden wurde, als bekannte Größe. Das geht, weil der Optimierer weiß, dass er zu dem Zeitpunkt, in dem die Abfrage den zweiten Schritt erreicht, alle Werte aus dem ersten Schritt kennt. Der ref-Typ der film_actor-Tabelle ist ebenfalls const, genau wie bei der film-Tabelle.
180 | Kapitel 4: Optimierung der Abfrageleistung
Eine weitere Möglichkeit, bei der Sie die Anwendung von Konstantenbedingungen sehen können, ist die Verbreitung der Konstantheit eines Wertes von einer Stelle zu einer anderen bei WHERE-, USING- oder ON-Klauseln, die verlangen, dass der Wert gleich ist. In diesem Beispiel weiß der Optimierer, dass die USING-Klausel film_id zwingt, überall in der Abfrage den gleichen Wert anzunehmen – er muss gleich dem konstanten Wert sein, der in der WHERE-Klausel übergeben wurde. Abdeckende Indizes MySQL kann manchmal einen Index einsetzen, um das Lesen von Zeilendaten zu vermeiden, wenn der Index alle Spalten enthält, die die Abfrage benötigt. Wir stellen abdeckende Indizes in Kapitel 3 ausführlich vor. Unterabfrageoptimierung MySQL kann manche Arten von Unterabfragen in effizientere alternative Formen verwandeln, wodurch sie auf Indexsuchen reduziert werden, anstatt separate Abfragen zu bilden. Frühe Terminierung MySQL kann die Verarbeitung einer Abfrage (oder eines Schrittes in einer Abfrage) stoppen, sobald die Abfrage oder der Schritt erfüllt ist. Der offensichtliche Fall ist eine LIMIT-Klausel, es gibt aber noch weitere Arten von frühzeitiger Terminierung. Falls z.B. MySQL eine unmögliche Bedingung entdeckt, kann es die gesamte Abfrage abbrechen. Schauen Sie sich das folgende Beispiel an: mysql> EXPLAIN SELECT film.film_id FROM sakila.film WHERE film_id = -1; +----+...+-----------------------------------------------------+ | id |...| Extra | +----+...+-----------------------------------------------------+ | 1 |...| Impossible WHERE noticed after reading const tables | +----+...+-----------------------------------------------------+
Diese Abfrage stoppte während des Optimierungsschrittes, MySQL kann die Ausführung in manchen Fällen aber auch früher beenden. Der Server kann diese Optimierung benutzen, wenn die Abfrageausführungs-Engine merkt, dass sie einzelne Werte abrufen oder dass sie stoppen muss, wenn ein Wert nicht existiert. So findet z.B. die folgende Abfrage alle Filme ohne Schauspieler:7 mysql> SELECT film.film_id -> FROM sakila.film -> LEFT OUTER JOIN sakila.film_actor USING(film_id) -> WHERE film_actor.film_id IS NULL;
Bei dieser Abfrage werden alle Filme eliminiert, die Schauspieler enthalten. Jeder Film könnte viele Schauspieler haben, sobald aber ein Schauspieler gefunden wird, wird die Verarbeitung des aktuellen Films gestoppt und zum nächsten Film weitergegangen, weil bekannt ist, dass die WHERE-Klausel das Ausgeben dieses Films verbietet. Eine ähnliche »Einzelwerte/nicht existent«-Optimierung kann auf bestimmte Arten von DISTINCT-, NOT EXISTS( )- und LEFT JOIN-Abfragen angewandt werden. 7 Es stimmt schon, ein Film ohne Schauspieler scheint seltsam zu sein, allerdings gibt die Sakila-Beispieldatenbank keine Schauspieler für »SLACKER LIAISONS« an. Sie beschreibt diesen Film als »Eine hektische Geschichte von einem Hai und einem Schüler, der im Alten China ein Krokodil treffen muss«.
Grundlagen der Abfrageverarbeitung | 181
Verbreitung von Gleichheit MySQL erkennt, wenn eine Abfrage zwei gleiche Spalten enthält – z.B. in einer JOINBedingung –, und verteilt WHERE-Klauseln über äquivalente Spalten. So etwa in der folgenden Abfrage: mysql> SELECT film.film_id -> FROM sakila.film -> INNER JOIN sakila.film_actor USING(film_id) -> WHERE film.film_id > 500;
MySQL weiß, dass die WHERE-Klausel nicht nur für die film-Tabelle, sondern auch für die film_actor-Tabelle gilt, weil die USING-Klausel die beiden Spalten zwingt zusammenzugehen. Falls Sie an einen anderen Datenbankserver gewöhnt sind, der so etwas nicht tut, wird Ihnen vielleicht geraten, »dem Optimierer zu helfen«, indem Sie die WHEREKlausel manuell für beide Tabellen angeben: ... WHERE film.film_id > 500 AND film_actor.film_id > 500
In MySQL ist das unnötig. Die Abfragen werden dadurch nur schwerer zu pflegen. IN( )-Listenvergleiche
Bei vielen Datenbankservern ist IN( ) nur ein Synonym für mehrere OR-Klauseln, da die beiden logisch äquivalent sind. Nicht so in MySQL, das die Werte in der IN( )Liste sortiert und mithilfe einer schnellen Binärsuche feststellt, ob sich ein Wert in der Liste befindet. Das ist O(log n) in der Größe der Liste, während eine äquivalente Folge von OR-Klauseln O(n) in der Größe der Liste ist (d.h., bei großen Listen viel langsamer abläuft). Die vorstehende Liste ist beklagenswert unvollständig, da MySQL mehr Optimierungen durchführt, als wir in dieses eine Kapitel pressen konnten. Sie sollte Ihnen aber einen Eindruck von der Komplexität und Intelligenz des Optimierers vermitteln. Wenn es eine Sache gibt, die Sie in diesem Abschnitt lernen sollten, dann ist es diese: Versuchen Sie nicht, den Optimierer zu überlisten. Sie könnten seine Bemühungen damit einfach nur vereiteln oder Ihre Abfragen und deren Pflege unnötig verkomplizieren, ohne dass Ihnen daraus ein Nutzen erwächst. Im Allgemeinen sollten Sie den Optimierer in Ruhe sein Werk verrichten lassen. Trotz aller Schlauheit gibt es natürlich auch Gelegenheiten, bei denen der Optimierer nicht das beste Ergebnis liefert. Manchmal wissen Sie vielleicht etwas über die Daten, was der Optimierer nicht weiß, wie etwa eine Tatsache, die aufgrund der Logik der Anwendung garantiert zutrifft. Manchmal verfügt der Optimierer auch nicht über die notwendige Funktionalität (wie etwa Hash-Indizes), oder seine Kostenschätzungen bevorzugen einen Abfrageplan, der teurer zu werden droht als eine Alternative. Wenn Sie wissen, dass der Optimierer kein gutes Ergebnis liefert, und Sie die Ursache kennen, können Sie etwas dagegen tun. Es wäre z.B. möglich, einen Hinweis zur Abfrage hinzuzufügen, die Abfrage umzuschreiben, das Schema umzugestalten oder Indizes hinzuzufügen.
182 | Kapitel 4: Optimierung der Abfrageleistung
Tabellen- und Indexstatistiken Rufen Sie sich die verschiedenen Ebenen der MySQL-Serverarchitektur wieder ins Gedächtnis, die wir in Abbildung 1-1 dargestellt haben. Die Serverebene, die den Abfrageoptimierer enthält, speichert keine Statistiken über Daten und Indizes. Das ist eine Aufgabe für die Storage-Engines, da jede Storage-Engine unterschiedliche Arten von Statistiken erheben (oder sie auf unterschiedliche Weise aufheben) könnte. Manche Engines, wie etwa Archive, besitzen überhaupt keine Statistiken! Da der Server keine Statistiken speichert, muss der MySQL-Abfrageoptimierer die Engines in einer Abfrage nach Statistiken über die Tabellen fragen. Die Engines könnten dem Optimierer Statistiken liefern, wie die Anzahl der Seiten pro Tabelle oder Index, die Kardinalität der Tabellen und Indizes, die Länge der Zeilen und Schlüssel und Informationen über die Schlüsselverteilung. Der Optimierer kann mithilfe dieser Informationen über den besten Ausführungsplan entscheiden. Wir werden später noch sehen, wie diese Statistiken die Entscheidungen des Optimierers beeinflussen.
Die Join-Ausführungsstrategie von MySQL MySQL verwendet den Begriff »Join« allgemeiner, als Sie es möglicherweise gewöhnt sind. Im Prinzip betrachtet es jede Abfrage als Join – nicht nur jede Abfrage, die Zeilen aus zwei Tabellen miteinander vergleicht, sondern jede Abfrage, Punkt (einschließlich Unterabfragen und sogar einem SELECT an einer einzigen Tabelle). Daher ist es sehr wichtig, dass Sie verstehen, wie MySQL Joins ausführt. Nehmen Sie das Beispiel einer UNION-Abfrage. MySQL führt ein UNION als eine Reihe einzelner Abfragen aus, deren Ergebnisse in eine temporäre Tabelle geschrieben und dann wieder ausgelesen werden. Jede der einzelnen Abfragen ist in der MySQL-Terminologie ein Join – genau wie der Akt des Lesens aus der resultierenden temporären Tabelle. Im Moment ist die MySQL-Join-Ausführungsstrategie einfach: Es behandelt alle Joins als Nested-Loop-Join (Geschachtelte-Schleife-Join). Das bedeutet, dass MySQL eine Schleife ausführt, um eine Zeile in einer Tabelle zu suchen, und dann eine geschachtelte Schleife ausführt, um eine passende Zeile in der nächsten Tabelle zu finden. Es fährt damit fort, bis es in jeder Tabelle des Joins eine passende Zeile gefunden hat. Es baut dann eine Zeile aus den Spalten zusammen, die in der SELECT-Liste genannt sind, und liefert sie zurück. Es versucht, die nächste Zeile zu erzeugen, indem es nach weiteren passenden Zeilen in der letzten Tabelle sucht. Findet es keine, geht es eine Tabelle zurück und sucht dort nach weiteren Zeilen. Mit diesem Zurückgehen macht es weiter, bis es eine weitere Zeile in irgendeiner Tabelle findet, von wo es dann wieder in der nächsten Tabelle nach einer passenden Zeile sucht, usw.8
8 Wie wir später zeigen werden, ist die Ausführung von Abfragen mit MySQL nicht ganz so einfach, da es viele Optimierungen gibt, die sie verkomplizieren.
Grundlagen der Abfrageverarbeitung | 183
Dieser Vorgang des Suchens von Zeilen, des Weitersuchens in der nächsten Tabelle und des Zurückgehens kann im Ausführungsplan in Form von geschachtelten Schleifen beschrieben werden – daher der Name. Betrachten Sie beispielsweise diese einfache Abfrage: mysql> SELECT tbl1.col1, tbl2.col2 -> FROM tbl1 INNER JOIN tbl2 USING(col3) -> WHERE tbl1.col1 IN(5,6);
Angenommen, MySQL beschließt, die Tabellen in der gezeigten Reihenfolge zusammenzuführen. Der folgende Pseudocode zeigt, wie MySQL die Abfrage ausführen könnte: outer_iter = iterator over tbl1 where col1 IN(5,6) outer_row = outer_iter.next while outer_row inner_iter = iterator over tbl2 where col3 = outer_row.col3 inner_row = inner_iter.next while inner_row output [ outer_row.col1, inner_row.col2 ] inner_row = inner_iter.next end outer_row = outer_iter.next end
Dieser Abfrageausführungsplan kann auf eine Eintabellenabfrage genauso leicht angewandt werden wie auf eine Mehrtabellenabfrage, weshalb sogar eine Eintabellenabfrage als Join angesehen wird – die Eintabellenabfrage ist schließlich die grundlegende Operation, aus der komplexere Joins zusammengesetzt werden. Er unterstützt auch OUTER JOINs. Ändern wir z.B. die Beispielabfrage wie folgt: mysql> SELECT tbl1.col1, tbl2.col2 -> FROM tbl1 LEFT OUTER JOIN tbl2 USING(col3) -> WHERE tbl1.col1 IN(5,6);
Hier ist der entsprechende Pseudocode; die geänderten Teile sind fettgedruckt: outer_iter = iterator over tbl1 where col1 IN(5,6) outer_row = outer_iter.next while outer_row inner_iter = iterator over tbl2 where col3 = outer_row.col3 inner_row = inner_iter.next if inner_row while inner_row output [ outer_row.col1, inner_row.col2 ] inner_row = inner_iter.next end else output [ outer_row.col1, NULL ] end outer_row = outer_iter.next end
184 | Kapitel 4: Optimierung der Abfrageleistung
Eine weitere Möglichkeit, einen Abfrageausführungsplan zu visualisieren, besteht darin, ein sogenanntes »Schwimmbahn-Diagramm« zu benutzen. Abbildung 4-2 enthält ein Schwimmbahn-Diagramm unserer ersten INNER JOIN-Abfrage. Lesen Sie es von links nach rechts und von oben nach unten. Tabellen tbl1
tbl2
Ergebniszeilen
Spl1=5, Spl3=1
Spl3=1, Spl2=1
Spl1=5, Spl2=1
Spl3=1, Spl2=2
Spl1=5, Spl2=2
Spl3=1, Spl2=3
Spl1=5, Spl2=3
Spl3=1, Spl2=1
Spl1=6, Spl2=1
Spl3=1, Spl2=2
Spl1=6, Spl2=2
Spl3=1, Spl2=3
Spl1=6, Spl2=3
Spl1=6, Spl3=1
Abbildung 4-2: Ein Schwimmbahn-Diagramm, das verdeutlicht, wie Zeilen mittels eines Joins abgefragt werden
MySQL führt im Prinzip alle Arten von Abfragen auf die gleiche Weise aus. Zum Beispiel verarbeitet es eine Unterabfrage in der FROM-Klausel, indem es sie zuerst ausführt, die Ergebnisse in eine temporäre Tabelle legt9 und dann diese Tabelle wie eine ganz normale Tabelle behandelt (daher der Name »abgeleitete Tabelle«). MySQL führt UNION-Abfragen ebenfalls mit temporären Tabellen aus und schreibt alle RIGHT OUTER JOIN-Abfragen in äquivalente LEFT OUTER JOIN-Abfragen um. Kurz gesagt zwingt MySQL jede Art von Abfrage in diesen Ausführungsplan. Es ist allerdings nicht möglich, jede zulässige SQL-Abfrage auf diese Weise auszuführen. So kann z.B. ein FULL OUTER JOIN nicht mit geschachtelten Schleifen und durch Zurückgehen ausgeführt werden, sobald eine Tabelle gefunden wurde, deren Zeilen nicht passen, da diese Operation mit einer Tabelle beginnen könnte, die keine passenden Zeilen enthält. Das erklärt, wieso MySQL FULL OUTER JOIN nicht unterstützt. Andere Abfragen können zwar mit geschachtelten Schleifen ausgeführt werden, laufen aber sehr schlecht. Wir schauen uns einige dieser Abfragen später noch an.
Der Ausführungsplan MySQL generiert im Gegensatz zu vielen anderen Datenbankprodukten keinen Bytecode, um eine Abfrage auszuführen. Stattdessen ist der Abfrageausführungsplan eigentlich ein Anweisungsbaum, den die Ausführungs-Engine durchläuft, um die Abfrageergebnisse zu 9 Es gibt keine Indizes in der temporären Tabelle. Das sollten Sie bedenken, wenn Sie komplexe Joins an Unterabfragen in der FROM-Klausel schreiben. Das gilt auch für UNION-Abfragen.
Grundlagen der Abfrageverarbeitung | 185
erzeugen. Der fertige Plan enthält genügend Informationen, um die Originalabfrage zu rekonstruieren. Wenn Sie EXPLAIN EXTENDED, gefolgt von SHOW WARNINGS, auf einer Abfrage ausführen, erhalten Sie die rekonstruierte Abfrage.10 Jede Mehrtabellenabfrage kann konzeptuell als Baum dargestellt werden. Es wäre z.B. möglich, einen Viertabellen-Join auszuführen, wie in Abbildung 4-3 gezeigt. Join
Join
tbl1
Join
tbl2
tbl3
tbl4
Abbildung 4-3: Eine Möglichkeit, mehrere Tabellen zusammenzuführen
Informatiker bezeichnen dies als balancierten Baum. Allerdings ist dies nicht die Art, wie MySQL die Abfrage ausführt. Wie wir im vorherigen Abschnitt beschrieben haben, beginnt MySQL immer mit einer Tabelle und sucht in der nächsten Tabelle nach passenden Zeilen. Abfrageausführungspläne von MySQL nehmen deshalb immer die Form eines Left-Deep Tree an wie in Abbildung 4-4. Join
Join
Join
tbl1
tbl4
tbl3
tbl2
Abbildung 4-4: Wie MySQL mehrere Tabellen zusammenführt
Der Join-Optimierer Der wichtigste Teil des MySQL-Abfrageoptimierers ist der Join-Optimierer, der die beste Ausführungsreihenfolge für Mehrtabellenabfragen festlegt. Oft ist es möglich, Tabellen in mehreren unterschiedlichen Anordnungen zusammenzuführen und dennoch die glei-
10 Der Server generiert die Ausgabe aus dem Ausführungsplan. Sie weist daher die gleiche Semantik wie die Originalabfrage auf, aber nicht unbedingt den gleichen Text.
186 | Kapitel 4: Optimierung der Abfrageleistung
chen Ergebnisse zu erhalten. Der Join-Optimierer schätzt die Kosten für die verschiedenen Pläne ab und versucht, den preiswertesten Plan auszuwählen, der das gewünschte Ergebnis liefert. Hier ist eine Abfrage, deren Tabellen in verschiedenen Anordnungen zusammengeführt werden können, ohne dass sich die Ergebnisse ändern: mysql> SELECT film.film_id, film.title, film.release_year, actor.actor_id, -> actor.first_name, actor.last_name -> FROM sakila.film -> INNER JOIN sakila.film_actor USING(film_id) -> INNER JOIN sakila.actor USING(actor_id);
Sie können sich wahrscheinlich noch ein paar andere Abfragepläne ausdenken. Zum Beispiel könnte MySQL mit der film-Tabelle beginnen, den Index in film_id in der film_actor-Tabelle verwenden, um actor_id-Werte zu finden, und dann Zeilen im Primärschlüssel der actor-Tabelle nachschlagen. Das sollte effizient sein, oder? Wir wollen nun mithilfe von EXPLAIN feststellen, wie MySQL die Abfrage ausführen möchte: *************************** 1. row *************************** id: 1 select_type: SIMPLE table: actor type: ALL possible_keys: PRIMARY key: NULL key_len: NULL ref: NULL rows: 200 Extra: *************************** 2. row *************************** id: 1 select_type: SIMPLE table: film_actor type: ref possible_keys: PRIMARY,idx_fk_film_id key: PRIMARY key_len: 2 ref: sakila.actor.actor_id rows: 1 Extra: Using index *************************** 3. row *************************** id: 1 select_type: SIMPLE table: film type: eq_ref possible_keys: PRIMARY key: PRIMARY key_len: 2 ref: sakila.film_actor.film_id rows: 1 Extra:
Grundlagen der Abfrageverarbeitung | 187
Dieser Plan unterscheidet sich von demjenigen aus dem vorhergehenden Absatz. MySQL möchte mit der actor-Tabelle beginnen (wir wissen das, weil sie in der EXPLAIN-Ausgabe als Erstes auftaucht) und in der umgekehrten Reihenfolge vorgehen. Ist das wirklich effizienter? Wir wollen es herausfinden. Das Schlüsselwort STRAIGHT_JOIN zwingt den Join, in der Reihenfolge fortzufahren, die in der Abfrage angegeben wurde. Hier ist die EXPLAINAusgabe für die überarbeitete Abfrage: mysql> EXPLAIN SELECT STRAIGHT_JOIN film.film_id...\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: film type: ALL possible_keys: PRIMARY key: NULL key_len: NULL ref: NULL rows: 951 Extra: *************************** 2. row *************************** id: 1 select_type: SIMPLE table: film_actor type: ref possible_keys: PRIMARY,idx_fk_film_id key: idx_fk_film_id key_len: 2 ref: sakila.film.film_id rows: 1 Extra: Using index *************************** 3. row *************************** id: 1 select_type: SIMPLE table: actor type: eq_ref possible_keys: PRIMARY key: PRIMARY key_len: 2 ref: sakila.film_actor.actor_id rows: 1 Extra:
Dies zeigt, weshalb MySQL die Join-Reihenfolge umkehren möchte: Auf diese Weise müsste es weniger Zeilen in der ersten Tabelle untersuchen.11 In beiden Fällen wäre es in der Lage, schnelle indizierte Lookups in der zweiten und dritten Tabelle durchzuführen. Der Unterschied besteht in der Anzahl dieser indizierten Lookups:
11 Genau genommen versucht MySQL nicht, die Anzahl der Zeilen, die es liest, zu reduzieren. Stattdessen versucht es, eine Optimierung in Richtung auf weniger Seitenleseoperationen durchzuführen. Die Zeilenzahl vermittelt Ihnen jedoch oft eine ungefähre Vorstellung von den Kosten der Abfrage.
188 | Kapitel 4: Optimierung der Abfrageleistung
• Würde film an die erste Stelle gesetzt, dann müssten 951 Sondierungen in film_ actor und actor durchgeführt werden, und zwar je eine für jede Zeile in der ersten Tabelle. • Scannt der Server die actor-Tabelle zuerst, muss er nur 200 Index-Lookups in später folgenden Tabellen durchführen. Mit anderen Worten: Die umgekehrte Join-Reihenfolge erfordert weniger Zurückgehen und erneutes Lesen. Um die Wahl des Optimierers noch einmal zu überprüfen, führten wir zwei Abfrageversionen durch und schauten uns jeweils die Variable Last_query_cost an. Die umsortierte Abfrage hatte geschätzte Kosten von 241, während die geschätzten Kosten zum Erzwingen der Join-Reihenfolge 1.154 betrugen. Dies ist ein einfaches Beispiel dafür, wie der Join-Optimierer von MySQL umsortieren kann, um die Ausführung preiswerter zu machen. Das Umsortieren von Joins ist normalerweise eine sehr effektive Optimierung. Manchmal jedoch ergibt sich kein optimaler Plan. In diesen Fällen können Sie STRAIGHT_JOIN verwenden und die Abfrage in der Anordnung schreiben, die Ihnen am besten vorkommt – solche Fälle sind aber selten. Meist ist der Join-Optimierer besser als ein Mensch. Der Join-Optimierer versucht, einen Abfrageausführungsplan mit den niedrigsten erreichbaren Kosten zu erzeugen. Wenn möglich, untersucht er alle potenziellen Kombinationen aus Teilbäumen, wobei er mit allen Eintabellenplänen beginnt. Leider ergibt ein Join über n Tabellen n-Fakultät Kombinationen aus Join-Anordnungen für die Untersuchung. Man bezeichnet dies als den Suchraum aller möglichen Abfragepläne; dieser wird sehr groß – ein 10-Tabellen-Join kann auf 3.628.800 unterschiedliche Arten ausgeführt werden! Wenn der Suchraum zu groß wird, dauert es möglicherweise viel zu lange, um die Abfrage zu optimieren, so dass der Server keine vollständige Analyse durchführt. Stattdessen greift er auf Abkürzungen zurück, wie etwa auf »Greedy«Suchen, wenn die Anzahl der Tabellen die Grenze optimizer_search_depth überschreitet. MySQL verfügt über viele im Laufe vieler Jahre des Forschens und Experimentierens gesammelte Heuristiken, die es anwendet, um das Optimierungsstadium zu beschleunigen. Das kann vorteilhaft sein, kann aber auch bedeuten, dass MySQL möglicherweise (obwohl es selten vorkommt) einen optimalen Plan verpasst und einen weniger optimalen Plan wählt, weil es versucht, nicht jeden möglichen Abfrageplan zu untersuchen. Manchmal können Abfragen nicht neu angeordnet werden. Der Join-Optimierer nutzt diese Tatsache, um den Suchraum zu verkleinern, indem er Möglichkeiten eliminiert. Ein LEFT JOIN ist ein gutes Beispiel, genau wie miteinander verwandte Unterabfragen (später mehr zu Unterabfragen). Das liegt daran, dass die Ergebnisse für eine Tabelle von Daten abhängen, die aus einer anderen Tabelle abgefragt werden. Diese Abhängigkeiten helfen dem Join-Optimierer, den Suchraum zu verringern, indem Möglichkeiten eliminiert werden.
Grundlagen der Abfrageverarbeitung | 189
Sortieroptimierungen Das Sortieren von Ergebnissen ist unter Umständen sehr kostenintensiv. Sie können deshalb die Leistung oft verbessern, indem Sie das Sortieren vermeiden oder es mit weniger Zeilen durchführen. Wir haben Ihnen in Kapitel 3 gezeigt, wie Sie Indizes zum Sortieren verwenden. Wenn MySQL keinen Index benutzen kann, um ein sortiertes Ergebnis zu erzeugen, muss es die Zeilen selbst sortieren. Dieser Vorgang wird, unabhängig davon, ob er im Speicher oder auf der Festplatte erfolgt, als Filesort bezeichnet, obwohl eigentlich überhaupt keine Datei benutzt wird. Wenn die Werte, die sortiert werden sollen, in den Sortierpuffer passen, kann MySQL das Sortieren mit einem Quicksort komplett im Speicher erledigen. Ist das Sortieren im Speicher nicht möglich, führt MySQL es auf der Festplatte aus, indem es die Werte gruppenweise sortiert. Das Sortieren der einzelnen Gruppen erfolgt mit einem Quicksort, anschließend werden die sortierten Gruppen zu den Ergebnissen zusammengefasst. Es gibt zwei Filesort-Algorithmen: Mit zwei Durchläufen (Two passes), alt Liest Zeilenzeiger und ORDER BY-Spalten, sortiert sie und scannt dann die sortierten Listen und liest die Zeilen erneut für die Ausgabe. Der Two-Pass-Algorithmus kann sehr aufwendig sein, weil er die Zeilen zweimal aus der Tabelle liest und der zweite Lesevorgang viele zufällige Ein-/Ausgaben verursacht. Vor allem für MyISAM ist dies teuer, da MyISAM einen Systemaufruf verwendet, um die einzelnen Zeilen abzurufen. (MyISAM greift nämlich auf den Cache des Betriebssystems zurück, um die Daten abzulegen.) Andererseits speichert er während der Sortierung nur eine minimale Menge an Daten. Wenn also die Zeilen komplett im Speicher sortiert werden können, kann es billiger sein, weniger Daten zu speichern und die Zeilen erneut zu lesen, um das endgültige Ergebnis zu generieren. Mit einem Durchlauf (Single Pass), neu Liest alle Spalten, die für die Abfrage benötigt werden, sortiert sie nach den ORDER BYSpalten, durchsucht dann die sortierte Liste und gibt die festgelegten Spalten aus. Diesen Algorithmus gibt es erst ab MySQL 4.1. Er kann viel effizienter sein, vor allem bei großen ein-/ausgabebasierten Datenmengen, da er die Zeilen aus der Tabelle nicht zweimal liest und statt zufälliger Ein-/Ausgaben sequenzielle Ein-/Ausgaben nutzt. Allerdings ist er möglicherweise sehr raumgreifend, da er alle gewünschten Spalten aus jeder einzelnen Zeile aufnimmt, nicht nur die Spalten, die zum Sortieren der Zeilen erforderlich sind. Das bedeutet, dass in den Sortierpuffer weniger Tupel passen und der Filesort-Algorithmus mehr Durchläufe zum Zusammenfassen der Sortierergebnisse benötigt. MySQL kann für einen Filesort viel mehr temporären Speicherplatz einsetzen, als Sie erwarten würden, da es für jedes Tupel, das es sortiert, einen Datensatz fester Größe reserviert. Diese Datensätze sind groß genug für das größtmögliche Tupel, einschließlich
190 | Kapitel 4: Optimierung der Abfrageleistung
der vollständigen Länge der einzelnen VARCHAR-Spalten. Falls Sie UTF-8 verwenden, stellt MySQL außerdem drei Byte für jedes Zeichen bereit. Wir haben aus diesem Grund schon Fälle gesehen, in denen schlecht optimierte Schemata dafür gesorgt haben, dass der temporäre Platz, der für das Sortieren verwendet wurde, viele Male größer war als die Größe der kompletten Tabelle auf der Festplatte. Beim Sortieren eines Joins kann MySQL den Filesort in zwei Stufen während der Abfrageausführung erledigen. Bezieht sich die ORDER BY-Klausel nur auf Spalten aus der ersten Tabelle in der Join-Reihenfolge, kann MySQL diese Tabelle mit Filesort sortieren und dann mit dem Join fortfahren. Wenn dies geschieht, zeigt EXPLAIN »Using filesort« in der Extra-Spalte. Ansonsten muss MySQL die Ergebnisse der Abfrage in einer temporären Tabelle speichern und diese Tabelle dann mit Filesort sortieren, wenn der Join abgeschlossen ist. In diesem Fall zeigt EXPLAIN »Using temporary; Using filesort« in der ExtraSpalte. Ein eventuell vorhandenes LIMIT wird nach dem Filesort angewendet, die temporäre Tabelle und der Filesort können also sehr groß werden. In »Für Filesorts optimieren« auf Seite 325 finden Sie weitere Informationen darüber, wie Sie den Server für Filesorts einstellen und wie Sie beeinflussen können, welchen Algorithmus der Server verwendet.
Die Abfrageausführungs-Engine Nach der Stufe des Parsens und Optimierens hat man einen Abfrageausführungsplan, den die Abfrageausführungs-Engine von MySQL benutzt, um die Abfrage zu verarbeiten. Bei dem Plan handelt es sich um eine Datenstruktur, nicht um ausführbaren Bytecode wie bei vielen anderen Datenbanken. Im Gegensatz zur Optimierung ist das Ausführungsstadium nicht besonders komplex: MySQL folgt einfach den Anweisungen des Abfrageausführungsplans. Viele der Operationen in dem Plan rufen Methoden auf, die im Interface der Storage-Engine, der sogenannten Handler API, implementiert sind. Jede Tabelle in der Abfrage wird durch eine Instanz eines Handlers repräsentiert. Wenn eine Tabelle z.B. dreimal in der Abfrage auftaucht, erzeugt der Server drei Handler-Instanzen. Wir haben diese Tatsache zwar ausgelassen, aber eigentlich erzeugt MySQL die Handler-Instanzen bereits früh im Optimierungsstadium. Der Optimierer holt mit ihnen Informationen über die Tabellen, wie etwa ihre Spaltennamen und die Indexstatistiken. Das Interface der Storage-Engine umfasst viele Funktionen, benötigt aber zum Ausführen der meisten Abfragen nur etwa ein Dutzend »Basis«-Operationen. So gibt es z.B. eine Operation zum Lesen der ersten Zeile in einem Index und eine zum Lesen der nächsten Zeile in einem Index. Das reicht für eine Abfrage, die einen Indexscan durchführt. Diese grob vereinfachende Ausführungsmethode ermöglicht erst die Storage-Engine-Architektur von MySQL, ist aber auch für einige der Optimiererbeschränkungen verantwortlich, die wir besprochen haben.
Grundlagen der Abfrageverarbeitung | 191
Nicht alles ist eine Handler-Operation. So verwaltet der Server z.B. Tabellen-Locks. Der Handler könnte auf niedrigerer Ebene sein eigenes Locking implementieren, wie etwa InnoDB mit seinen Row-Level-Locks. Das ersetzt aber nicht die servereigene Locking-Implementierung. Wie in Kapitel 1 erläutert wurde, ist alles, was allen Storage-Engines gemein ist, im Server implementiert, wie etwa Datums- und Uhrzeitfunktionen, Sichten und Trigger.
Um die Abfrage auszuführen, wiederholt der Server einfach die Anweisungen, bis keine Zeilen mehr übrig sind, die untersucht werden müssten.
Zurückliefern der Ergebnisse an den Client Der letzte Schritt beim Ausführen einer Abfrage ist die Antwort an den Server. Selbst Abfragen, die keine Ergebnismenge zurückliefern, geben an die Clientverbindung Informationen über die Abfrage zurück, wie etwa die Anzahl der Zeilen, die sie bearbeitet haben. Wenn die Abfrage cache-fähig ist, setzt MySQL die Ergebnisse in dieser Stufe außerdem in den Abfrage-Cache. Der Server generiert und sendet die Ergebnisse inkrementell. Denken Sie an die Multijoin-Methode in einem Durchgang, die wir erwähnt haben. Sobald MySQL die letzte Tabelle verarbeitet und eine Zeile erfolgreich generiert, kann und sollte es diese Zeile an den Client senden. Das hat zwei Vorteile: Der Server muss die Zeile nicht im Speicher ablegen, und der Client bekommt die Ergebnisse so früh wie möglich.12
Grenzen des MySQL-Abfrageoptimierers Der MySQL-Ansatz des »alles ist ein Join mit geschachtelter Schleife« für die Abfrageausführung ist nicht unbedingt am besten zum Optimieren aller Arten von Abfragen geeignet. Glücklicherweise kommt es relativ selten vor, dass der MySQL-Abfrageoptimierer nicht so gut funktioniert, und normalerweise ist es möglich, solche Abfragen effizienter umzuschreiben. Die Informationen in diesem Abschnitt gelten für MySQL-Serverversionen, auf die wir zum Zeitpunkt der Entstehung dieses Buches Zugriff hatten, d.h. bis zu MySQL 5.1. Einige dieser Beschränkungen werden wahrscheinlich in künftigen Versionen gelockert oder aufgehoben, und einige von ihnen sind bereits aus Versionen verschwunden, die noch nicht als GA (generally available, d.h. allgemein verfügbar) veröffentlicht wurden. So gibt es im MySQL 6-Quellcode speziell einige Optimierungen für Unterabfragen, und weitere werden folgen. 12 Sie können dieses Verhalten bei Bedarf beeinflussen, z.B. mit dem Hinweis SQL_BUFFER_RESULT (siehe »Hinweise für den Abfrageoptimierer« auf Seite 210).
192 | Kapitel 4: Optimierung der Abfrageleistung
Korrelierte Unterabfragen Manchmal optimiert MySQL Unterabfragen nur sehr schlecht. Die schlimmsten Missetäter sind IN( )-Unterabfragen in der WHERE-Klausel. Wir wollen als Beispiel alle Filme in der sakila.film-Tabelle der Sakila-Beispieldatenbank finden, zu deren Besetzung die Schauspielerin Penelope Guiness (actor_id=1) gehört. Das scheint mit einer solchen Unterabfrage schnell erledigt zu sein: mysql> SELECT * FROM sakila.film -> WHERE film_id IN( -> SELECT film_id FROM sakila.film_actor WHERE actor_id = 1);
Es ist verlockend, sich vorzustellen, dass MySQL diese Abfrage von innen nach außen ausführt, indem es eine Liste mit actor_id-Werten sucht und diese in die IN( )-Liste einsetzt. Wir haben gesagt, dass eine IN( )-Liste im Allgemeinen sehr schnell ist, so dass Sie vermutlich erwarten, dass die Abfrage etwa so optimiert werden würde: -- SELECT GROUP_CONCAT(film_id) FROM sakila.film_actor WHERE actor_id = 1; -- Result: 1,23,25,106,140,166,277,361,438,499,506,509,605,635,749,832,939,970,980 SELECT * FROM sakila.film WHERE film_id IN(1,23,25,106,140,166,277,361,438,499,506,509,605,635,749,832,939,970,980) ;
Leider tritt genau der entgegengesetzte Fall ein. MySQL versucht, der Unterabfrage zu »helfen«, indem es eine Beziehung aus der äußeren Tabelle in die Abfrage herstellt, von der es glaubt, dass sie die Unterabfrage effizienter die Zeilen finden lässt. Es schreibt die Abfrage folgendermaßen um: SELECT * FROM sakila.film WHERE EXISTS ( SELECT * FROM sakila.film_actor WHERE actor_id = 1 AND film_actor.film_id = film.film_id);
Jetzt verlangt die Unterabfrage die film_id aus der äußeren film-Tabelle und kann nicht mehr zuerst ausgeführt werden. EXPLAIN zeigt das Ergebnis als DEPENDENT SUBQUERY (mit EXPLAIN EXTENDED können Sie genau feststellen, wie die Abfrage umgeschrieben wurde): mysql> EXPLAIN SELECT * FROM sakila.film ...; +----+--------------------+------------+--------+------------------------+ | id | select_type | table | type | possible_keys | +----+--------------------+------------+--------+------------------------+ | 1 | PRIMARY | film | ALL | NULL | | 2 | DEPENDENT SUBQUERY | film_actor | eq_ref | PRIMARY,idx_fk_film_id | +----+--------------------+------------+--------+------------------------+
Entsprechend der EXPLAIN-Ausgabe durchsucht MySQL die film-Tabelle und führt die Unterabfrage für jede Zeile aus, die es findet. Bei kleinen Tabellen hat dies noch keine merklichen Auswirkungen auf die Leistung; wenn hingegen die äußere Tabelle sehr groß ist, fällt die Leistung außerordentlich stark ab. Zum Glück ist es einfach, eine solche Abfrage in einen JOIN umzuschreiben: mysql> SELECT film.* FROM sakila.film -> INNER JOIN sakila.film_actor USING(film_id) -> WHERE actor_id = 1;
Grenzen des MySQL-Abfrageoptimierers | 193
Eine weitere gute Optimierung besteht darin, die IN( )-Liste manuell zu generieren, indem man die Unterabfrage als separate Abfrage mit GROUP_CONCAT( ) ausführt. Manchmal kann das schneller sein als ein JOIN. MySQL ist für diese spezielle Art von Ausführungsplan für Unterabfragen gründlich gescholten worden. Obwohl hier sicher Verbesserungsbedarf besteht, bringt die Kritik oft zwei Probleme durcheinander: Ausführungsreihenfolge und Caching. Das Ausführen der Abfrage von innen nach außen ist eine Möglichkeit, sie zu optimieren; das Speichern des Ergebnisses der inneren Abfrage im Cache eine andere. Indem Sie die Abfrage selbst umschreiben, können Sie beide Aspekte kontrollieren. Künftige Versionen von MySQL sollten in der Lage sein, diese Art von Abfrage besser zu optimieren, auch wenn dies keine einfache Aufgabe darstellt. Es gibt für jeden Ausführungsplan ziemlich ungünstige Fälle. Dazu gehört auch der Von-innen-nach-außen-Ausführungsplan, von dem manche Leute glauben, er wäre leicht zu optimieren.
Wann eine korrelierte Unterabfrage gut ist Manchmal ist MySQL beim Optimieren von Unterabfragen gar nicht so schlecht. Hören Sie nicht zu, wenn man Ihnen rät, sie immer zu vermeiden! Testen Sie sie stattdessen selbst, und treffen Sie Ihre eigenen Entscheidungen. Manchmal ist eine korrelierte Unterabfrage absolut vernünftig oder sogar optimal, um zum Ergebnis zu kommen. Schauen wir uns ein Beispiel an: mysql> EXPLAIN SELECT film_id, language_id FROM sakila.film -> WHERE NOT EXISTS( -> SELECT * FROM sakila.film_actor -> WHERE film_actor.film_id = film.film_id -> )\G *************************** 1. row *************************** id: 1 select_type: PRIMARY table: film type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 951 Extra: Using where *************************** 2. row *************************** id: 2 select_type: DEPENDENT SUBQUERY table: film_actor type: ref possible_keys: idx_fk_film_id key: idx_fk_film_id key_len: 2 ref: film.film_id rows: 2 Extra: Using where; Using index
194 | Kapitel 4: Optimierung der Abfrageleistung
Der normale Ratschlag für diese Abfrage lautet, sie als LEFT OUTER JOIN zu schreiben, anstatt eine Unterabfrage zu verwenden. Theoretisch sieht der MySQL-Ausführungsplan beide Male gleich aus. Schauen Sie: mysql> EXPLAIN SELECT film.film_id, film.language_id -> FROM sakila.film -> LEFT OUTER JOIN sakila.film_actor USING(film_id) -> WHERE film_actor.film_id IS NULL\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: film type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 951 Extra: *************************** 2. row *************************** id: 1 select_type: SIMPLE table: film_actor type: ref possible_keys: idx_fk_film_id key: idx_fk_film_id key_len: 2 ref: sakila.film.film_id rows: 2 Extra: Using where; Using index; Not exists
Die Pläne sind fast identisch, es gibt aber einige Unterschiede: • Der SELECT-Typ an film_actor ist DEPENDENT SUBQUERY in einer Abfrage und SIMPLE in der anderen. Dieser Unterschied spiegelt einfach die Syntax wider, weil die erste Abfrage eine Unterabfrage verwendet und die zweite nicht. In Bezug auf die Handler-Operationen gibt es keinen großen Unterschied. • Bei der zweiten Abfrage steht nicht »Using where« in der Extra-Spalte für die filmTabelle. Das macht allerdings nichts: Die USING-Klausel der zweiten Abfrage ist sowieso das Gleiche wie eine WHERE-Klausel. • Die zweite Abfrage sagt »Not exists« in der Extra-Spalte der film_actor-Tabelle. Dies ist ein Beispiel für den frühzeitig terminierten Algorithmus, den wir bereits weiter vorn in diesem Kapitel erwähnt haben. Es bedeutet, dass MySQL eine NotExists-Optimierung verwendet, um zu vermeiden, dass es mehr als eine Zeile im idx_fk_film_id-Index der film_actor-Tabelle lesen muss. Das ist äquivalent zu einer korrelierten NOT EXISTS( )-Unterabfrage, weil es die Verarbeitung der aktuellen Zeile stoppt, sobald ein Treffer gefunden wird.
Grenzen des MySQL-Abfrageoptimierers | 195
Theoretisch führt MySQL also die Abfragen fast gleich aus. In Wirklichkeit können Sie nur mithilfe eines Benchmark-Tests feststellen, welcher Ansatz schneller ist. Wir haben beide Abfragen in unserer Standardeinstellung getestet. Die Ergebnisse sehen Sie in Tabelle 4-1. Tabelle 4-1: NOT EXISTS im Vergleich mit LEFT OUTER JOIN Abfrage
Ergebnisse in Abfragen pro Sekunde (Queries per Second; QPS)
NOT EXISTS-Unterabfrage
360 QPS
LEFT OUTER JOIN
425 QPS
Unser Benchmark hat ergeben, dass die Unterabfrage etwas langsamer ist! Das ist jedoch nicht immer der Fall. Manchmal kann eine Unterabfrage auch schneller sein. Sie kann z.B. gut funktionieren, wenn Sie einfach nur Zeilen aus einer Tabelle sehen wollen, die Zeilen aus einer anderen Tabelle entsprechen. Das klingt zwar so, als würde es perfekt einen Join beschreiben, ist aber nicht immer das Gleiche. Der folgende Join, der dazu gedacht ist, jeden Film zu finden, der einen Schauspieler besitzt, liefert Duplikate zurück, weil manche Filme mehrere Schauspieler haben: mysql> SELECT film.film_id FROM sakila.film -> INNER JOIN sakila.film_actor USING(film_id);
Wir müssen DISTINCT oder GROUP BY verwenden, um die Duplikate zu eliminieren: mysql> SELECT DISTINCT film.film_id FROM sakila.film -> INNER JOIN sakila.film_actor USING(film_id);
Aber was wollen wir wirklich mit dieser Abfrage ausdrücken, und wird dies aus dem SQL deutlich? Der EXISTS-Operator drückt das logische Konzept von »hat einen Treffer« aus, ohne dass duplizierte Zeilen erzeugt werden, und vermeidet eine GROUP BY- oder DISTINCTOperation, die eine temporäre Tabelle erfordern könnte. Dies ist die Abfrage, geschrieben als Unterabfrage und nicht als Join: mysql> SELECT film_id FROM sakila.film -> WHERE EXISTS(SELECT * FROM sakila.film_actor -> WHERE film.film_id = film_actor.film_id);
Wir haben wieder mit einem Benchmark festgestellt, welche Strategie schneller ist. Die Ergebnisse finden Sie in Tabelle 4-2. Tabelle 4-2: EXISTS im Vergleich mit INNER JOIN Abfrage
Ergebnis in Abfragen pro Sekunde (Queries per Second; QPS)
INNER JOIN
185 QPS
EXISTS-Unterabfrage
325 QPS
In diesem Beispiel wird die Unterabfrage viel schneller ausgeführt als der Join.
196 | Kapitel 4: Optimierung der Abfrageleistung
Wir wollten mit diesem ausführlichen Beispiel zwei Punkte verdeutlichen: Sie sollten grundsätzlichen Ratschlägen in Bezug auf Unterabfragen nicht kritiklos folgen, und Sie sollten Benchmarks einsetzen, um Ihre Annahmen über Abfragepläne und Ausführungsgeschwindigkeiten zu bestätigen.
UNION-Beschränkungen Manchmal kann MySQL Bedingungen von außerhalb einer UNION nicht nach innen »durchreichen«, wo sie Ergebnisse begrenzen oder zusätzliche Optimierungen erlauben könnten. Falls Sie glauben, dass eine der jeweiligen Abfragen innerhalb einer UNION von einem LIMIT profitieren könnte, oder wenn Sie wissen, dass sie von einer ORDER BY-Klausel beansprucht wird, sobald man sie mit anderen Abfragen kombiniert, dann müssen Sie diese Klauseln in jeden Teil der UNION setzen. Wenn Sie z.B. zwei riesige Tabellen mit UNION vereinigen und das Ergebnis mit LIMIT auf die ersten 20 Zeilen beschränken, speichert MySQL die beiden riesigen Tabellen in einer temporären Tabelle und holt dann nur die 20 Zeilen aus ihr. Sie können das vermeiden, indem Sie in jede Abfrage innerhalb der UNION ein LIMIT 20 setzen.
Index-Merge-Optimierungen Index-Merge-Algorithmen, die in MySQL 5.0 eingeführt wurden, erlauben es MySQL, in einer Abfrage mehr als einen Index pro Tabelle zu verwenden. Frühere Versionen von MySQL konnten nur einen einzigen Index benutzen; wenn also ein einzelner Index nicht ausreichte, um mit all den Beschränkungen in der WHERE-Klausel zurechtzukommen, wählte MySQL oft einen Tabellenscan. So hat z.B. die film_actor-Tabelle einen Index in film_id und einen Index in actor_id, aber keiner von beiden ist eine gute Wahl für die beiden WHERE-Bedingungen in dieser Abfrage: mysql> SELECT film_id, actor_id FROM sakila.film_actor -> WHERE actor_id = 1 OR film_id = 1;
In älteren MySQL-Versionen würde diese Abfrage einen Tabellenscan verursachen, es sei denn, Sie hätten sie als UNION der beiden Abfragen geschrieben: mysql> SELECT film_id, actor_id FROM sakila.film_actor WHERE actor_id = 1 -> UNION ALL -> SELECT film_id, actor_id FROM sakila.film_actor WHERE film_id = 1 -> AND actor_id <> 1;
Seit MySQL 5.0 jedoch kann diese Abfrage beide Indizes benutzen, sie gleichzeitig scannen und die Ergebnisse zusammenfassen. Es gibt drei Variationen des Algorithmus: Vereinigung für OR-Bedingungen, Durchschnitte für AND-Bedingungen und Vereinigungen aus Durchschnitten für Kombinationen aus den beiden. Die folgende Abfrage nutzt eine Vereinigung aus zwei Indexscans, wie Sie erkennen, wenn Sie sich die Extra-Spalte anschauen:
Grenzen des MySQL-Abfrageoptimierers | 197
mysql> EXPLAIN SELECT film_id, actor_id FROM sakila.film_actor -> WHERE actor_id = 1 OR film_id = 1\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: film_actor type: index_merge possible_keys: PRIMARY,idx_fk_film_id key: PRIMARY,idx_fk_film_id key_len: 2,2 ref: NULL rows: 29 Extra: Using union(PRIMARY,idx_fk_film_id); Using where
MySQL kann diese Technik bei komplexen WHERE-Klauseln einsetzen, so dass Sie bei manchen Abfragen geschachtelte Operationen in der Extra-Spalte finden. Das funktioniert oft sehr gut, manchmal allerdings belegen die Puffer-, Sortier- und Merge-Operationen des Algorithmus viele CPU- und Speicherressourcen. Das trifft vor allem dann zu, wenn nicht alle Indizes sehr selektiv sind, so dass die parallelen Scans viele Zeilen an die Merge-Operation zurückliefern. Erinnern Sie sich daran, dass der Optimierer diese Kosten nicht berücksichtigt – er optimiert nur die Anzahl der zufälligen Seitenlesevorgänge. Das kann dazu führen, dass er die Abfrage »unterbewertet«, die tatsächlich viel langsamer läuft als ein einfacher Tabellenscan. Die intensive Speicher- und CPU-Benutzung beeinflusst darüber hinaus oft auch nebenläufige Abfragen, was Ihnen aber nicht auffallen wird, wenn Sie die Abfrage isoliert ausführen. Das ist ein weiterer Grund für realistische Benchmarks. Falls Ihre Abfragen aufgrund dieser Optimiererbeschränkung langsamer laufen, könnten Sie entweder einige Indizes mit IGNORE INDEX deaktivieren oder einfach auf die alte UNIONTaktik zurückgreifen.
Verbreitung von Gleichheit Die Verbreitung von Gleichheit kann manchmal unerwartete Kosten mit sich bringen. Nehmen Sie z.B. eine riesige IN( )-Liste in einer Spalte, die der Optimierer aufgrund einer WHERE-, ON- oder USING-Klausel, die die Spalten einander gleichsetzt, als gleich mit anderen Spalten in anderen Tabellen betrachtet. Der Optimierer »verteilt« die Liste, indem er sie in die entsprechenden Spalten in allen verwandten Tabellen kopiert. Normalerweise ist das hilfreich, weil es dem Abfrageoptimierer und der Ausführungs-Engine mehr Möglichkeiten dafür bietet, wo diese tatsächlich den IN( )-Test ausführen sollen. Wenn aber eine Liste sehr groß ist, kann dies zu langsamerer Optimierung und Ausführung führen. Momentan gibt es für dieses Problem keine bereits integrierte Lösung – Sie müssen den Quellcode ändern, wenn es für Sie ein Problem darstellt. (Für die meisten Leute ist es kein Problem.)
198 | Kapitel 4: Optimierung der Abfrageleistung
Parallele Ausführung MySQL kann auf vielen CPUs eine einzelne Abfrage nicht parallel ausführen. Das ist eine Eigenschaft, die von einigen anderen Datenbankservern angeboten wird, nicht jedoch von MySQL. Wir erwähnen das hier, damit Sie keine Zeit damit verschwenden, eine parallele Abfrageausführung unter MySQL zum Laufen zu bringen!
Hash-Joins MySQL kann momentan keine echten Hash-Joins ausführen – alles ist ein Join mit geschachtelter Schleife. Sie können allerdings Hash-Joins mit Hash-Indizes emulieren. Wenn Sie nicht gerade die Memory-Storage-Engine einsetzen, müssen Sie auch die HashIndizes emulieren. Wir haben Ihnen dies in »Eigene Hash-Indizes aufbauen« auf Seite 111 gezeigt.
Lockere Indexscans MySQL war noch nie in der Lage, lockere Indexscans durchzuführen, bei denen unzusammenhängende Bereiche eines Index gescannt werden. Die MySQL-Indexscans erfordern im Allgemeinen einen definierten Anfangspunkt und einen definierten Endpunkt im Index, selbst wenn nur einige unzusammenhängende Zeilen in der Mitte wirklich für die Abfrage von Interesse sind. MySQL scannt den gesamten Zeilenbereich zwischen diesen Endpunkten. Ein Beispiel soll das verdeutlichen. Nehmen Sie an, wir haben eine Tabelle mit einem Index in den Spalten (a, b) und wollen folgende Abfrage durchführen: mysql> SELECT ... FROM tbl WHERE b BETWEEN 2 AND 3;
Da der Index mit Spalte a beginnt, die WHERE-Klausel der Abfrage Spalte a aber nicht angibt, führt MySQL einen Tabellenscan durch und eliminiert die nicht passenden Zeilen mit einer WHERE-Klausel, wie in Abbildung 4-5 zu sehen ist. Es ist leicht zu erkennen, dass es eine schnellere Methode gibt, um diese Abfrage auszuführen. Die Struktur des Index (aber nicht die API der MySQL-Storage-Engine) erlaubt es Ihnen, zum Beginn des jeweiligen Wertebereichs zu gehen, bis zum Ende des Bereichs zu scannen und dann zurückzugehen und zum Anfang des nächsten Bereichs zu springen. Abbildung 4-6 zeigt, wie diese Strategie aussehen würde, wenn MySQL in der Lage wäre, sie zu benutzen. Beachten Sie das Fehlen einer WHERE-Klausel, die nicht erforderlich ist, weil der Index allein es uns erlaubt, die unerwünschten Zeilen auszulassen. (Noch einmal, MySQL kann das noch nicht.) Das ist zugegebenermaßen ein vereinfachtes Beispiel, und wir könnten die gezeigte Abfrage leicht optimieren, indem wir einen anderen Index hinzufügten. Allerdings kommt es oft vor, dass ein anderer Index das Problem nicht löst. Ein Beispiel ist eine Abfrage, die eine Bereichsbedingung in der ersten Spalte des Index aufweist und eine Gleichheitsbedingung in der zweiten Spalte.
Grenzen des MySQL-Abfrageoptimierers | 199
Abbildung 4-5: MySQL scannt die gesamte Tabelle, um Zeilen zu suchen.
Abbildung 4-6: Ein lockerer Indexscan, zu dem MySQL momentan nicht in der Lage ist, wäre viel effizienter.
Seit MySQL 5.0 sind lockere Indexscans unter bestimmten, stark eingeschränkten Umständen möglich, etwa bei Abfragen, die maximale und minimale Werte in einer gruppierten Abfrage suchen:
200 | Kapitel 4: Optimierung der Abfrageleistung
mysql> EXPLAIN SELECT actor_id, MAX(film_id) -> FROM sakila.film_actor -> GROUP BY actor_id\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: film_actor type: range possible_keys: NULL key: PRIMARY key_len: 2 ref: NULL rows: 396 Extra: Using index for group-by
Die »Using index for group-by«-Information in diesem EXPLAIN-Plan kennzeichnet einen lockeren Indexscan. Für diesen speziellen Zweck ist das eine gute Optimierung, allerdings lässt sich dieser lockere Indexscan nicht verallgemeinern. Vermutlich wäre es besser, dies als »lockere Indexuntersuchung« zu bezeichnen. Bis MySQL allgemeingültige lockere Indexscans unterstützt, muss man eine Konstante oder eine Liste aus Konstanten für die führenden Spalten des Index liefern. Wir haben in unserer Indizierungsfallstudie im vorangegangenen Kapitel mehrere Beispiele dafür gezeigt, wie man eine gute Leistung mit solchen Abfragen erreicht.
MIN( ) und MAX( ) MySQL optimiert bestimmte MIN( )- und MAX( )-Abfragen nicht sehr gut. Hier ist ein Beispiel: mysql> SELECT MIN(actor_id) FROM sakila.actor WHERE first_name = 'PENELOPE';
Da es keinen Index in first_name gibt, führt diese Abfrage einen Tabellenscan durch. Wenn MySQL den Primärschlüssel scannt, kann es theoretisch nach dem Lesen der ersten passenden Zeile stoppen, weil der Primärschlüssel streng ansteigend ist und jede nachfolgende Zeile eine größere actor_id besitzt. In diesem Fall jedoch scannt MySQL die gesamte Tabelle. Sie können das durch ein Profiling der Abfrage überprüfen. Eine Möglichkeit, das zu umgehen, besteht darin, das MIN( ) zu entfernen und die Abfrage mit einem LIMIT umzuschreiben: mysql> SELECT actor_id FROM sakila.actor USE INDEX(PRIMARY) -> WHERE first_name = 'PENELOPE' LIMIT 1;
Diese allgemeine Strategie funktioniert oft ganz gut, wenn MySQL ansonsten beschließen würde, mehr Zeilen als notwendig zu scannen. Wenn Sie ein Purist sind, könnten Sie einwenden, dass diese Abfrage den Zweck von SQL verfehlt. Wir sollten dazu in der Lage sein, dem Server mitzuteilen, was wir wollen, und er soll herausfinden können, wie er an diese Daten herankommt, während wir in diesem Fall MySQL sagen, wie es die Abfrage ausführen soll, und es daher aus der Abfrage nicht deutlich wird, dass das, was wir suchen, ein Minimalwert ist. Manchmal müssen Sie eben mit Blick auf Ihre Prinzipien Kompromisse eingehen, um eine hohe Leistung zu erzielen. Grenzen des MySQL-Abfrageoptimierers | 201
SELECT und UPDATE in derselben Tabelle MySQL erlaubt es Ihnen nicht, ein SELECT in einer Tabelle auszuführen, während gleichzeitig ein UPDATE darin läuft. Eigentlich ist das keine Beschränkung des Optimierers, allerdings hilft es Ihnen, damit zurechtzukommen, wenn Sie wissen, wie MySQL Abfragen ausführt. Hier ist ein Beispiel für eine Abfrage, die nicht zulässig ist, obwohl es sich dabei um normales SQL handelt. Die Abfrage aktualisiert jede Zeile mit der Anzahl ähnlicher Zeilen in der Tabelle: mysql> UPDATE tbl AS outer_tbl -> SET cnt = ( -> SELECT count(*) FROM tbl AS inner_tbl -> WHERE inner_tbl.type = outer_tbl.type -> ); ERROR 1093 (HY000): You can't specify target table 'outer_tbl' for update in FROM clause
Um diese Beschränkung zu umgehen, können Sie eine abgeleitete Tabelle einsetzen, da MySQL diese als temporäre Tabelle ausführt. Damit werden im Prinzip zwei Abfragen ausgeführt: ein SELECT innerhalb der Unterabfrage und ein Mehrtabellen-UPDATE mit den zusammengeführten Ergebnissen der Tabelle und der Unterabfrage. Die Unterabfrage öffnet und schließt die Tabelle, bevor das äußere UPDATE die Tabelle öffnet, so dass die Abfrage erfolgreich verläuft: mysql> UPDATE tbl -> INNER JOIN( -> SELECT type, count(*) AS cnt -> FROM tbl -> GROUP BY type -> ) AS der USING(type) -> SET tbl.cnt = der.cnt;
Bestimmte Arten von Abfragen optimieren In diesem Abschnitt zeigen wir Ihnen, wie Sie bestimmte Arten von Abfragen optimieren. Wir haben die meisten dieser Themen an anderen Stellen in diesem Buch ausführlicher behandelt, wollten aber für einen leichteren Zugang eine Liste von häufiger auftretenden Optimierungsproblemen aufstellen. Die meisten der Hinweise in diesem Abschnitt sind versionsabhängig und gelten möglicherweise für künftige Versionen von MySQL nicht. Es gibt keinen Grund, weshalb der Server nicht irgendwann in der Lage sein sollte, einige oder alle Optimierungen selbst zu erledigen.
COUNT( )-Abfragen optimieren Die Aggregatfunktion COUNT( ) und ihre Verwendung zum Optimieren von Abfragen, die sie verwenden, gehört wahrscheinlich zu den 10 am meisten missverstandenen Themen in MySQL. Sie können eine Websuche durchführen und werden mehr Fehlinformationen zu diesem Thema finden, als wir uns vorzustellen wagen. Bevor wir zur Optimierung kommen, sollten Sie verstehen lernen, was COUNT( ) wirklich tut. 202 | Kapitel 4: Optimierung der Abfrageleistung
Was COUNT( ) macht COUNT( ) ist eine Spezialfunktion, die auf zwei unterschiedliche Arten funktioniert: Sie zählt Werte und Zeilen. Ein Wert ist ein Nicht-NULL-Ausdruck (NULL bezeichnet die Abwe-
senheit eines Wertes). Wenn Sie einen Spaltennamen oder einen anderen Ausdruck in den Klammern angeben, zählt COUNT( ), wie oft dieser Ausdruck einen Wert besitzt. Das ist für viele Leute verwirrend, zum Teil, weil Werte und NULL verwirrend sind. Falls Sie lernen müssen, wie das in SQL funktioniert, raten wir Ihnen zu einem guten Buch über die SQL-Grundlagen. (Das Internet ist in diesem Fall nicht unbedingt eine zuverlässige Informationsquelle.) Die andere Form von COUNT( ) zählt einfach die Anzahl der Zeilen im Ergebnis. Das ist genau, was MySQL tut, wenn es weiß, dass der Ausdruck in den Klammern niemals NULL sein kann. Das bekannteste Beispiel ist COUNT(*), eine Sonderform von COUNT( ), die das *-Wildcard nicht zur vollständigen Liste der Spalten in der Tabelle erweitert, wie Sie vielleicht vermuten würden, sondern die Spalten völlig ignoriert und die Zeilen zählt. Einer der Fehler, die uns am häufigsten auffallen, besteht darin, dass Spaltennamen in den Klammern angegeben werden, wenn man Zeilen zählen möchte. Wenn Sie die Anzahl der Zeilen im Ergebnis wissen möchten, sollten Sie immer COUNT(*) benutzen. Dies macht Ihre Wünsche deutlich und verhindert Leistungseinbrüche.
Mythen über MyISAM Ein weiteres Missverständnis besagt, dass MyISAM außergewöhnlich schnell bei COUNT( )-Abfragen ist. Es ist schnell, aber nur in einem Sonderfall: COUNT(*) ohne WHEREKlausel, das nur die Anzahl der Zeilen in der gesamten Tabelle ermittelt. MySQL kann das wegoptimieren, da die Storage-Engine immer weiß, wie viele Zeilen in der Tabelle stehen. Wenn MySQL weiß, dass col nie NULL sein kann, kann es auch einen COUNT(col)Ausdruck optimieren, indem es ihn intern in COUNT(*) umwandelt. MyISAM besitzt keine magischen Geschwindigkeitsoptimierungen zum Zählen von Zeilen, wenn die Abfrage eine WHERE-Klausel enthält, oder für den allgemeineren Fall, dass Werte anstelle von Zeilen gezählt werden. Es kann bei einer bestimmten Abfrage schneller sein als andere Storage-Engines, ist es aber vielleicht auch nicht. Das hängt von vielen Faktoren ab.
Einfache Optimierungen Manchmal können Sie die COUNT(*)-Optimierung von MyISAM zu Ihrem Vorteil einsetzen, wenn Sie alle bis auf eine kleine Anzahl von Zeilen zählen wollen, die gut indiziert sind. Das folgende Beispiel nutzt die normale World-Datenbank, um Ihnen zu zeigen, wie Sie effizient die Anzahl der Städte ermitteln, deren ID größer als 5 ist. Sie könnten diese Abfrage folgendermaßen schreiben: mysql> SELECT COUNT(*) FROM world.City WHERE ID > 5;
Bestimmte Arten von Abfragen optimieren | 203
Wenn Sie diese Abfrage mit SHOW STATUS profilieren, dann sehen Sie, dass sie 4.079 Zeilen scannt. Falls Sie die Bedingungen negieren und die Anzahl der Städte, deren IDs kleiner oder gleich 5 sind, von der Gesamtanzahl der Städte abziehen, können Sie das auf fünf Zeilen reduzieren: mysql> SELECT (SELECT COUNT(*) FROM world.City) - COUNT(*) -> FROM world.City WHERE ID <= 5;
Diese Version liest weniger Zeilen, weil die Unterabfrage während der Optimierungsphase in eine Konstante umgewandelt wurde, wie Sie mit EXPLAIN erkennen können: +----+-------------+-------+...+------+------------------------------+ | id | select_type | table |...| rows | Extra | +----+-------------+-------+...+------+------------------------------+ | 1 | PRIMARY | City |...| 6 | Using where; Using index | | 2 | SUBQUERY | NULL |...| NULL | Select tables optimized away | +----+-------------+-------+...+------+------------------------------+
Eine häufig gestellte Frage auf Mailinglisten und in IRC-Kanälen lautet, wie man mit nur einer Abfrage die Zahlen für mehrere verschiedene Werte in derselben Spalte ermittelt, um die Anzahl der erforderlichen Abfragen zu verringern. Nehmen Sie z.B. an, dass Sie eine einzige Abfrage erzeugen wollen, die zählen soll, wie viele Objekte je eine von mehreren Farben haben. Sie können kein OR verwenden (wie in SELECT COUNT(color = 'blue' OR color = 'red') FROM items;), weil dies die verschiedenen Zähler für die verschiedenen Farben nicht trennt. Und Sie können die Farben nicht in die WHERE-Klausel setzen (z.B. SELECT COUNT(*) FROM items WHERE color = 'blue' AND color = 'red';), weil die Farben einander ausschließen. Hier ist eine Abfrage, die dieses Problem löst: mysql> SELECT SUM(IF(color = 'blue', 1, 0)) AS blue, SUM(IF(color = 'red', 1, 0)) -> AS red FROM items;
Dies ist eine weitere Abfrage, die äquivalent zu der gezeigten ist. Anstelle von SUM( ) wird allerdings COUNT( ) verwendet, und außerdem wird sichergestellt, dass die Ausdrücke keine Werte haben, wenn die Kriterien falsch sind: mysql> SELECT COUNT(color = 'blue' OR NULL) AS blue, COUNT(color = 'red' OR NULL) -> AS red FROM items;
Komplexere Optimierungen Im Allgemeinen sind COUNT( )-Abfragen schwer zu optimieren, weil sie normalerweise viele Zeilen zählen (d.h. auf viele Daten zugreifen) müssen. Ihre einzige andere Möglichkeit zum Optimieren in MySQL selbst besteht darin, einen abdeckenden Index einzusetzen. Abdeckende Indizes haben wir in Kapitel 3 vorgestellt. Falls das nicht ausreicht, müssen Sie Ihre Anwendungsarchitektur ändern. Ziehen Sie Summary-Tabellen (diese wurden ebenfalls in Kapitel 3 behandelt) und vielleicht ein externes Cache-System wie memcached in Betracht. Wahrscheinlich werden Sie mit dem vertrauten Dilemma konfrontiert: »Schnell, akkurat und einfach: Wählen Sie zwei!«
204 | Kapitel 4: Optimierung der Abfrageleistung
JOIN-Abfragen optimieren Dieses Thema finden Sie an vielen Stellen in diesem Buch, wir wollen aber zumindest einige Kernpunkte erwähnen: • Stellen Sie sicher, dass es Indizes in den Spalten in den ON- oder USING-Klauseln gibt. Mehr über Indizierung finden Sie in »Grundlagen der Indizierung« auf Seite 103. Beachten Sie die Join-Reihenfolge, wenn Sie Indizes hinzufügen. Wenn Sie die Tabellen A und B in Spalte c zusammenführen und der Abfrageoptimierer beschließt, den Join der Tabellen in der Reihenfolge B, A durchzuführen, müssen Sie die Spalten in Tabelle B nicht indizieren. Nicht genutzte Indizes bedeuten zusätzlichen Overhead. Im Allgemeinen müssen Sie nur der zweiten Tabelle in der Join-Reihenfolge Indizes hinzufügen, es sei denn, die Indizes werden aus anderen Gründen benötigt. • Versuchen Sie sicherzustellen, dass sich alle GROUP BY- oder ORDER BY-Ausdrücke nur auf Spalten aus einer einzigen Tabelle beziehen, damit MySQL versuchen kann, einen Index für diese Operation zu benutzen. • Seien Sie vorsichtig, wenn Sie MySQL aufrüsten, da sich die Join-Syntax, die Rangordnung der Operatoren und andere Verhaltensweisen öfter einmal geändert haben. Was einmal ein normaler Join war, wird manchmal zu einem Kreuzprodukt (einer anderen Art von Join, die andere Ergebnisse zurückliefert) oder sogar zu ungültiger Syntax.
Unterabfragen optimieren Der wichtigste Rat, den wir Ihnen zu Unterabfragen geben können, ist der, dass Sie nach Möglichkeit lieber einen Join einsetzen sollten, zumindest in aktuellen Versionen von MySQL. Wir haben dieses Thema weiter vorn in diesem Kapitel ausführlich behandelt. Unterabfragen werden vom Optimiererteam intensiv bearbeitet, so dass kommende MySQL-Versionen möglicherweise mehr Unterabfragenoptimierungen enthalten werden. Es bleibt abzwarten, welche der Optimierungen, die wir gesehen haben, es bis in den endgültigen Code schaffen und welche Auswirkungen sie haben werden. Wir wollen Ihnen nur klarmachen, dass »nehmen Sie lieber einen Join« kein ewig gültiger Ratschlag ist. Der Server wird mit der Zeit immer besser werden und Sie werden ihm immer seltener sagen müssen, was er tun soll, anstatt ihm mitzuteilen, welche Ergebnisse Sie sehen wollen.
GROUP BY und DISTINCT optimieren MySQL optimiert diese beiden Arten von Abfragen in vielen Fällen ähnlich. Um genau zu sein, konvertiert es sie während der Optimierung sogar bei Bedarf intern ineinander. Beide Arten von Abfragen profitieren üblicherweise von Indizes, was auch die wichtigste Methode ist, um sie zu optimieren.
Bestimmte Arten von Abfragen optimieren | 205
MySQL kennt zwei Arten von GROUP BY-Strategien, wenn es keinen Index benutzen kann: Es kann eine temporäre Tabelle oder einen Filesort verwenden, um die Gruppierung durchzuführen. Jeweils beide können sich bei bestimmten Abfragen als effizienter erweisen. Sie können den Optimierer zwingen, mithilfe der Optimiererhinweise SQL_BIG_ RESULT und SQL_SMALL_RESULT die eine oder andere Methode zu wählen. Falls Sie einen Join nach einem Wert gruppieren müssen, der aus einer Lookup-Tabelle stammt, dann ist es meist effizienter, die Gruppierung anhand des Identifikators der Lookup-Tabelle vorzunehmen als anhand des Wertes. So ist etwa die folgende Abfrage nicht so effizient, wie sie sein könnte: mysql> SELECT actor.first_name, actor.last_name, COUNT(*) -> FROM sakila.film_actor -> INNER JOIN sakila.actor USING(actor_id) -> GROUP BY actor.first_name, actor.last_name;
Die Abfrage ist effizienter, wenn sie so geschrieben wird: mysql> SELECT actor.first_name, actor.last_name, COUNT(*) -> FROM sakila.film_actor -> INNER JOIN sakila.actor USING(actor_id) -> GROUP BY film_actor.actor_id;
Das Gruppieren nach actor.actor_id könnte effizienter sein als das Gruppieren nach film_actor.actor_id. Sie sollten dies mit Ihren speziellen Daten profilieren oder testen. Diese Abfrage nutzt die Tatsache aus, dass Vor- und Nachname des Schauspielers von der actor_id abhängen, liefert also die gleichen Ergebnisse. Es ist aber nicht immer der Fall, dass Sie munter nichtgruppierte Spalten auswählen können und das gleiche Ergebnis erhalten. Möglicherweise ist sogar der SQL_MODE des Servers so konfiguriert, dass dies verboten ist. Sie können notfalls MIN( ) oder MAX( ) einsetzen, wenn Sie wissen, dass die Werte innerhalb der Gruppe verschieden sind, weil sie von der grouped-by-Spalte abhängen oder weil es Ihnen egal ist, welchen Wert Sie erhalten: mysql> SELECT MIN(actor.first_name), MAX(actor.last_name), ...;
Puristen werden einwenden, dass Sie nach der falschen Sache gruppieren, und sie haben Recht. Ein unberechtigtes MIN( ) oder MAX( ) ist das Zeichen dafür, dass die Abfrage nicht richtig strukturiert ist. Manchmal allerdings ist es einfach Ihr einziges Bestreben, dass MySQL die Abfrage so schnell wie möglich ausführt. Die Puristen werden mit der folgenden Art, die Abfrage zu schreiben, zufrieden sein: mysql> SELECT actor.first_name, actor.last_name, c.cnt -> FROM sakila.actor -> INNER JOIN ( -> SELECT actor_id, COUNT(*) AS cnt -> FROM sakila.film_actor -> GROUP BY actor_id -> ) AS c USING(actor_id) ;
Manchmal sind allerdings die Kosten zum Erzeugen und Füllen der temporären Tabelle, die für die Unterabfrage benötigt wird, hoch im Vergleich mit den Kosten für das Verfäl-
206 | Kapitel 4: Optimierung der Abfrageleistung
schen der reinen relationalen Theorie. Denken Sie daran, dass die temporäre Tabelle, die von der Unterabfrage erzeugt wird, keine Indizes hat. Es ist im Allgemeinen keine gute Idee, nichtgruppierte Spalten in einer gruppierten Abfrage auszuwählen, weil die Ergebnisse nichtdeterministisch sind und sich leicht ändern können, wenn Sie einen Index ändern oder der Optimierer beschließt, eine andere Strategie einzusetzen. Die meisten dieser Abfragen, die uns begegnen, sind Unfälle (weil der Server sich nicht beschwert) oder das Ergebnis von Faulheit und wurden nicht zum Zwecke der Optimierung so geschaffen. Es ist besser, explizit zu sein. Wir empfehlen Ihnen sogar, die Konfigurationsvariable SQL_MODE des Servers so einzustellen, dass sie ONLY_FULL_GROUP_BY einschließt, damit sie einen Fehler ausgibt, anstatt Sie eine schlechte Abfrage schreiben zu lassen. MySQL ordnet gruppierte Abfragen automatisch nach den Spalten in der GROUP BY-Klausel, wenn Sie keine ORDER BY-Klausel explizit angeben. Falls Sie sich nicht um die Reihenfolge kümmern und feststellen, dass dies einen Filesort verursacht, können Sie ORDER BY NULL verwenden, um das automatische Sortieren zu überspringen. Sie können direkt hinter die GROUP BY-Klausel auch ein optionales DESC- oder ASC-Schlüsselwort setzen, um die Ergebnisse in der gewünschten Richtung anzuordnen.
GROUP BY WITH ROLLUP optimieren Eine Variante der gruppierten Abfragen ist, wenn Sie MySQL anweisen, innerhalb der Ergebnisse eine Superaggregation durchzuführen. Dies erreichen Sie mit einer WITH ROLLUPKlausel, es ist aber möglicherweise nicht so gut optimiert, wie Sie es brauchen. Prüfen Sie die Ausführungsmethode mit EXPLAIN, wobei Sie besonders darauf achten, ob die Gruppierung über einen Filesort oder über eine temporäre Tabelle erfolgt; versuchen Sie, das WITH ROLLUP zu entfernen und festzustellen, ob Sie die gleiche Gruppierungsmethode erhalten. Vielleicht können Sie die Gruppierungsmethode auch mit den Hinweisen erzwingen, die wir weiter vorn in diesem Abschnitt erwähnt haben. Manchmal ist es effizienter, die Superaggregation in Ihrer Anwendung durchzuführen, selbst wenn das bedeutet, dass Sie viel mehr Zeilen vom Server holen müssen. Sie können eine Teilabfrage auch in die FROM-Klausel schachteln oder eine temporäre Tabelle für die Zwischenergebnisse verwenden. Der beste Ansatz ist es möglicherweise, die WITH ROLLUP-Funktionalität in Ihren Anwendungscode zu verschieben.
LIMIT und OFFSET optimieren Abfragen mit LIMITs und OFFSETs sind in Systemen gebräuchlich, die Paginierungen durchführen, und zwar fast immer in Verbindung mit einer ORDER BY-Klausel. Es hilft, einen Index zu haben, der die Sortierung unterstützt, da der Server ansonsten viele Filesorts durchführen muss.
Bestimmte Arten von Abfragen optimieren | 207
Ein häufig auftretendes Problem ist ein hoher Wert für den Offset. Wenn Ihre Abfrage wie LIMIT 10000, 20 aussieht, dann generiert sie 10.020 Zeilen und wirft die ersten 10.000 von ihnen weg, was sehr teuer ist. Wenn Sie einmal annehmen, dass auf alle Seiten gleich häufig zugegriffen wird, dann scannen solche Abfragen durchschnittlich die halbe Tabelle. Um sie zu optimieren, können Sie entweder die Anzahl der Seiten beschränken, die in einer Paginierungsansicht erlaubt sind, oder versuchen, die hohen Offsets effizienter zu machen. Eine einfache Technik zum Verbessern der Effizienz besteht darin, den Offset in einem abdeckenden Index einzustellen und nicht in den vollständigen Zeilen. Sie können das Ergebnis dann zur kompletten Zeile zusammenfügen und die zusätzlichen Zeilen bei Bedarf holen. Betrachten Sie die folgende Abfrage: mysql> SELECT film_id, description FROM sakila.film ORDER BY title LIMIT 50, 5;
Wenn die Tabelle sehr groß ist, dann sollte die Abfrage besser so geschrieben werden: mysql> SELECT film.film_id, film.description -> FROM sakila.film -> INNER JOIN ( -> SELECT film_id FROM sakila.film -> ORDER BY title LIMIT 50, 5 -> ) AS lim USING(film_id);
Das funktioniert, weil dadurch der Server so wenige Daten wie möglich in einem Index untersucht, ohne auf Zeilen zuzugreifen. Sobald dann die gewünschten Zeilen gefunden wurden, führt er sie mit der vollständigen Tabelle zusammen, um die anderen Spalten aus der Zeile zu holen. Eine ähnliche Technik gilt für Joins mit LIMIT-Klauseln. Manchmal kann man das Limit auch in eine Positionsabfrage umwandeln, die der Server als Indexbereichsscan ausführen kann. Falls Sie z.B. eine Positionsspalte vorberechnen und indizieren, können Sie die Abfrage folgendermaßen umschreiben: mysql> SELECT film_id, description FROM sakila.film -> WHERE position BETWEEN 50 AND 54 ORDER BY position;
Klassifizierte Daten werfen ein ähnliches Problem auf, bringen allerdings normalerweise GROUP BY auf den Plan. Sie müssen Ränge fast immer vorberechnen und speichern. Falls Sie wirklich Paginierungssysteme optimieren müssen, sollten Sie wahrscheinlich auf vorberechnete Zusammenfassungen zurückgreifen. Alternativ können Sie Joins mit redundanten Tabellen vornehmen, die nur den Primärschlüssel und die Spalten enthalten, die Sie für das ORDER BY benötigen. Sie können auch Sphinx verwenden; Näheres dazu finden Sie in Anhang C.
SQL_CALC_FOUND_ROWS optimieren Eine weitere verbreitete Technik für die seitenweise Anzeige besteht darin, den Hinweis SQL_CALC_FOUND_ROWS zu einer Abfrage mit einem LIMIT hinzuzufügen, damit Sie wissen, wie viele Zeilen ohne das LIMIT zurückgeliefert worden wären. Es scheint so auszusehen,
208 | Kapitel 4: Optimierung der Abfrageleistung
als wäre irgendeine Art von »Magie« in Gang, mit der der Server vorhersagt, wie viele Zeilen er gefunden haben würde. Leider aber tut der Server nichts dergleichen; er kann Zeilen, die er eigentlich nicht findet, nicht zählen. Diese Option weist den Server lediglich an, den Rest der Ergebnismenge zu generieren und wegzuwerfen, anstatt anzuhalten, wenn er die gewünschte Anzahl an Zeilen erreicht. Das ist sehr teuer. Ein besserer Entwurf sieht so aus, dass der Pager in einen »Nächste«-Link umgewandelt wird. Angenommen, es gibt 20 Ergebnisse pro Seite. Die Abfrage sollte in diesem Fall ein LIMIT von 21 Zeilen benutzen und nur 20 anzeigen. Wenn die 21. Zeile existiert, dann gibt es eine nächste Seite, und Sie können den »Nächste«-Link rendern. Eine andere Möglichkeit besteht darin, mehr Zeilen, als Sie brauchen – sagen wir, 1.000 – zu holen und im Cache zu speichern, und sie dann für nachfolgende Seiten aus dem Cache zu beziehen. Diese Strategie lässt Ihre Anwendung wissen, wie groß die vollständige Ergebnismenge ist. Wenn es weniger als 1.000 Zeilen sind, dann weiß die Anwendung, wie viele Seitenlinks erstellt werden müssen. Sind es mehr als 1.000 Zeilen, dann kann sie einfach »Es wurden mehr als 1.000 Ergebnisse gefunden« anzeigen. Beide Strategien sind effizienter, als wenn wiederholt das gesamte Ergebnis generiert und der größte Teil davon verworfen wird. Selbst wenn Sie diese Taktiken nicht einsetzen, kann eine separate COUNT(*)-Abfrage zum Ermitteln der Zeilenzahl schneller sein als SQL_CALC_FOUND_ROWS, wenn sie einen abdeckenden Index benutzen kann.
UNION optimieren MySQL führt UNION-Abfragen immer aus, indem es eine temporäre Tabelle anlegt und diese mit den UNION-Ergebnissen füllt. MySQL kann auf UNION-Abfragen nicht so viele Optimierungen anwenden, wie Sie vielleicht gewöhnt sind. Möglicherweise müssen Sie dem Optimierer helfen, indem Sie ihm manuell WHERE-, LIMIT-, ORDER BY- und andere Bedingungen übergeben (d.h., sie bei Bedarf aus der äußeren Abfrage in jedes SELECT in dem UNION kopieren). Es ist wichtig, immer UNION ALL zu verwenden, es sei denn, der Server soll duplizierte Zeilen eliminieren. Wenn Sie das Schlüsselwort ALL weglassen, fügt MySQL der temporären Tabelle die Option distinct hinzu, die die vollständige Zeile verwendet, um Eindeutigkeit festzustellen. Das ist ziemlich teuer. Seien Sie sich allerdings bewusst, dass das Schlüsselwort ALL nicht die temporäre Tabelle eliminiert. MySQL setzt Ergebnisse immer in eine temporäre Tabelle und liest sie dann wieder aus, selbst wenn das nicht unbedingt notwendig ist (wenn etwa die Ergebnisse direkt an den Client zurückgeliefert werden könnten).
Bestimmte Arten von Abfragen optimieren | 209
Hinweise für den Abfrageoptimierer MySQL besitzt einige Optimiererhinweise, mit deren Hilfe Sie den Abfrageplan steuern können, wenn Sie mit demjenigen nicht zufrieden sind, den der MySQL-Optimierer auswählt. Die folgende Liste zeigt diese Hinweise und gibt an, wann man sie günstigerweise benutzen sollte. Sie setzen den entsprechenden Hinweis in die Abfrage, deren Plan Sie modifizieren wollen. Er ist dann nur für diese Abfrage wirksam. Im MySQL-Handbuch finden Sie die exakte Syntax der einzelnen Hinweise. Einige von ihnen sind versionsabhängig. Die Optionen sind: HIGH_PRIORITY und LOW_PRIORITY
Diese Hinweise teilen MySQL mit, wie es die Anweisung in Bezug auf andere Anweisungen priorisieren soll, die versuchen, auf die gleichen Tabellen zuzugreifen. HIGH_PRIORITY teilt MySQL mit, dass es eine SELECT-Anweisung vor den anderen
Anweisungen eintakten soll, die vielleicht auf Locks warten, damit sie die Daten modifizieren können. Im Prinzip kommt das SELECT an den Anfang der Warteschlange, anstatt warten zu müssen, bis es dran ist. Sie können diesen Modifikator auch auf INSERT anwenden, wo er einfach die Wirkung einer globalen LOW_PRIORITYServereinstellung aufhebt. LOW_PRIORITY ist genau das Gegenteil: Es sorgt dafür, dass die Anweisung am Ende
der Warteschlange wartet, falls es andere Anweisungen gibt, die auf die Tabelle zugreifen wollen – selbst wenn die anderen Anweisungen erst später aufgerufen wurden. Stellen Sie sich einfach eine übertrieben höfliche Person vor, die anderen im Restaurant die Tür aufhält: Solange noch irgendjemand kommt, bekommt diese Person nichts zu essen! Sie können diesen Hinweis auf SELECT-, INSERT-, UPDATE-, REPLACE- und DELETE-Anweisungen anwenden. Diese Hinweise sind bei Storage-Engines mit Locking auf Tabellenebene wirksam, bei InnoDB oder anderen Storage-Engines mit einem feinkörnigen Locking und Nebenläufigkeitskontrolle sollten Sie sie dagegen niemals benötigen. Passen Sie auf, wenn Sie sie bei MyISAM verwenden, da sie nebenläufige Einfügeoperationen außer Kraft setzen und die Leistungsfähigkeit stark beeinträchtigen können. Die Hinweise HIGH_PRIORITY und LOW_PRIORITY sind oft Grund für Verwirrung. Sie belegen nicht einfach mehr oder weniger Ressourcen für Abfragen, um sie »schwerer arbeiten« oder »nicht so schwer arbeiten« zu lassen; stattdessen beeinflussen sie, wie der Server Anweisungen in die Warteschlange einreiht, die auf den Zugriff auf eine Tabelle warten. DELAYED
Dieser Hinweis soll mit INSERT und REPLACE benutzt werden. Er ermöglicht es der Anwendung, auf die er angewandt wird, sofort zurückzukehren, und legt die eingefügten Zeilen in einen Puffer. Diese Zeilen werden dann zusammen eingefügt, wenn die Tabelle frei ist. Das eignet sich besonders für die Protokollierung und ähnliche Anwendungen, bei denen Sie viele Zeilen einfügen wollen, ohne dass der Client war-
210 | Kapitel 4: Optimierung der Abfrageleistung
ten muss und ohne dass für jede Anweisung eine Ein-/Ausgabe verursacht wird. Es gibt hier viele Beschränkungen; so sind z.B. verzögerte Einfügeoperationen nicht in allen Storage-Engines implementiert, und LAST_INSERT_ID( ) funktioniert nicht mit ihnen. STRAIGHT_JOIN
Dieser Hinweis kann entweder direkt hinter dem SELECT-Schlüsselwort in einer SELECT-Anweisung oder in einer beliebigen Anweisung zwischen zwei mit einem Join zusammengefügten Tabellen auftauchen. Die erste Anwendung sorgt dafür, dass alle Tabellen in der Abfrage in der Reihenfolge zusammengefügt werden, in der sie in der Anweisung aufgeführt sind. Die zweite Anwendung erzwingt eine Join-Reihenfolge in den beiden Tabellen, zwischen denen der Hinweis steht. Der Hinweis STRAIGHT_JOIN wird sinnvollerweise dann eingesetzt, wenn MySQL keine gute Join-Reihenfolge gewählt hat oder wenn der Optimierer sehr lange braucht, um eine Join-Reihenfolge festzulegen. Im zweiten Fall verbringt der Thread viel Zeit im »Statistics«-Zustand; durch das Hinzufügen dieses Hinweises wird der Suchraum für den Optimierer reduziert. Sie können mithilfe von EXPLAIN feststellen, welche Reihenfolge der Optimierer wählen würde, dann die Abfrage in dieser Reihenfolge umschreiben und STRAIGHT_JOIN hinzufügen. Das ist so lange eine gute Idee, wie Sie nicht glauben, dass die festgelegte Reihenfolge bei einigen WHERE-Klauseln zu einer schlechten Leistung führt. Denken Sie daran, solche Abfragen erneut anzuschauen, wenn Sie auf eine höhere MySQL-Version umsteigen, da es neue Optimierungen geben könnte, die von STRAIGHT_JOIN vereitelt werden. SQL_SMALL_RESULT und SQL_BIG_RESULT Diese Hinweise sind für SELECT-Anweisungen. Sie teilen dem Optimierer mit, wie und wann er temporäre Tabellen und Sortierungen in GROUP BY- oder DISTINCT-Abfragen benutzen soll. SQL_SMALL_RESULT sagt dem Optimierer, dass die Ergebnismenge
klein sein wird und in indizierte temporäre Tabellen gelegt werden kann, um das Sortieren für das Gruppieren zu vermeiden, während SQL_BIG_RESULT anzeigt, dass das Ergebnis groß sein wird, so dass es besser ist, temporäre Tabellen auf der Festplatte mit Sortierung zu benutzen. SQL_BUFFER_RESULT
Dieser Hinweis weist den Optimierer an, die Ergebnisse in eine temporäre Tabelle zu legen und Tabellen-Locks so schnell wie möglich wieder aufzuheben. Dies unterscheidet sich von der clientseitigen Pufferung, die wir in »Das MySQL-Client/ServerProtokoll« auf Seite 173 beschrieben haben. Serverseitiges Puffern kann ganz sinnvoll sein, wenn Sie keine Pufferung auf dem Client einsetzen, da Sie damit vermeiden, auf dem Client viel Speicher zu belegen, und Sperren ebenfalls schnell aufgehoben werden. Nachteilig ist, dass anstelle des Client-Speichers der Speicher des Servers belegt wird.
Hinweise für den Abfrageoptimierer
| 211
SQL_CACHE und SQL_NO_CACHE
Diese Hinweise teilen dem Server mit, dass die Abfrage entweder ein Kandidat für die Ablage im Abfrage-Cache ist oder nicht. Im nächsten Kapitel erfahren Sie genauer, wie Sie das benutzen. SQL_CALC_FOUND_ROWS
Dieser Hinweis weist MySQL an, eine vollständige Ergebnismenge zu berechnen, wenn es eine LIMIT-Klausel gibt, auch wenn nur LIMIT Zeilen zurückgeliefert werden. Sie können die Gesamtzahl der gefundenen Zeilen über FOUND_ROWS( ) erfahren. (Lesen Sie allerdings »SQL_CALC_FOUND_ROWS optimieren« auf Seite 208; dort erfahren Sie, weshalb Sie diesen Hinweis nicht benutzen sollten.) FOR UPDATE und LOCK IN SHARE MODE
Diese Hinweise kontrollieren das Locking bei SELECT-Anweisungen, allerdings nur bei Storage-Engines, die Row-Level-Locks besitzen. Sie erlauben es Ihnen, auf den gefundenen Zeilen Sperren anzulegen, was ganz gut sein kann, wenn Sie Zeilen sperren wollen, die Sie später aktualisieren werden, oder wenn Sie eine Lock-Eskalation vermeiden und daher so bald wie möglich exklusive Locks auslösen wollen. Diese Hinweise sind für INSERT ... SELECT-Abfragen nicht nötig, die standardmäßig in MySQL 5.0 Lese-Locks auf den Quellzeilen setzen. (Sie können dieses Verhalten deaktivieren, allerdings raten wir davon ab – die Gründe dafür erläutern wir in den Kapiteln 8 und 11.) MySQL 5.1 kann diese Beschränkung unter bestimmten Bedingungen aufheben. Momentan unterstützt nur InnoDB diese Hinweise. Es ist auch noch zu früh zu sagen, welche anderen Storage-Engines mit Row-Level-Locks sie künftig unterstützen werden. Wenn Sie diese Hinweise mit InnoDB benutzen, dann sollten Sie sich bewusst sein, dass sie einige Optimierungen, wie etwa abdeckende Indizes, deaktivieren könnten. InnoDB kann Zeilen nicht exklusiv sperren, ohne auf den Primärschlüssel zuzugreifen, wo die Versionsinformationen für die Zeilen gespeichert werden. USE INDEX, IGNORE INDEX und FORCE INDEX
Diese Hinweise sagen dem Optimierer, welche Indizes er zum Suchen von Zeilen in einer Tabelle benutzen oder ignorieren soll (z.B. wenn er eine Join-Reihenfolge festlegt). Bis MySQL 5.0 haben sie keinen Einfluss darauf, welche Indizes der Server zum Sortieren und Gruppieren verwendet, in MySQL 5.1 kann die Syntax eine optionale FOR ORDER BY- oder FOR GROUP BY-Klausel übernehmen. FORCE INDEX ist das Gleiche wie USE INDEX, sagt dem Optimierer aber, dass ein Tabel-
lenscan im Vergleich zum Index außerordentlich teuer ausfällt, selbst wenn der Index nicht besonders nützlich ist. Sie können diese Hinweise benutzen, wenn Sie nicht davon überzeugt sind, dass der Optimierer den richtigen Index wählt, oder wenn Sie aus irgendeinem Grund einen ganz bestimmten Index haben wollen, etwa weil Sie eine implizite Sortierung ohne ORDER BY durchführen wollen. Ein Beispiel dafür lieferten wir Ihnen in »LIMIT und OFFSET optimieren« auf Seite 207, wo wir Ihnen zeigten, wie Sie mit LIMIT effizient einen Minimalwert erhielten.
212 | Kapitel 4: Optimierung der Abfrageleistung
Seit MySQL 5.0 gibt es darüber hinaus noch Systemvariablen, die den Optimierer beeinflussen: optimizer_search_depth
Diese Variable teilt dem Optimierer mit, wie gründlich er Teilpläne untersuchen soll. Falls Ihre Abfragen sehr lange im Zustand »Statistics« verbleiben, sollten Sie versuchen, diesen Wert zu verringern. optimizer_prune_level
Diese Variable, die standardmäßig aktiviert ist, erlaubt es dem Optimierer, basierend auf der Anzahl der untersuchten Zeilen, bestimmte Pläne zu überspringen. Beide Optionen kontrollieren Optimiererabkürzungen. Diese Abkürzungen sind sehr wertvoll, um eine gute Leistung bei komplexen Abfragen zu erreichen, können aber auch dafür sorgen, dass der Server um der Effizienz willen optimale Pläne verfehlt. Daher ist es manchmal sinnvoll, sie zu ändern.
Benutzerdefinierte Variablen Man verliert die benutzerdefinierten Variablen von MySQL leicht aus den Augen, allerdings können sie sehr nützlich beim Schreiben effizienter Abfragen sein. Sie funktionieren besonders gut für Abfragen, die von einer Mischung aus prozeduraler und relationaler Logik profitieren. Rein relationale Abfragen behandeln alles als ungeordnete Mengen, die der Server irgendwie alle auf einmal manipuliert. MySQL geht einen pragmatischeren Weg. Dieser kann eine Schwäche sein, kann aber auch zu einer Stärke werden, wenn Sie wissen, wie Sie ihn richtig nutzen. Benutzerdefinierte Variablen helfen Ihnen dabei. Benutzerdefinierte Variablen sind temporäre Container für Werte, die so lange bestehen wie Ihre Verbindung zum Server. Sie definieren Sie, indem Sie sie einfach mit einer SEToder SELECT-Anweisung zuweisen:13 mysql> SET @one := 1; mysql> SET @min_actor := (SELECT MIN(actor_id) FROM sakila.actor); mysql> SET @last_week := CURRENT_DATE-INTERVAL 1 WEEK;
Sie können die Variablen dann an den meisten Stellen einsetzen, an denen auch ein Ausdruck stehen könnte: mysql> SELECT ... WHERE col <= @last_week;
Bevor wir uns mit den Stärken der benutzerdefinierten Variablen befassen, wollen wir uns einige ihrer Eigenarten und Nachteile anschauen und feststellen, wofür Sie sie nicht benutzen können: • Benutzerdefinierte Variablen verhindern Abfrage-Caching. • Sie können sie nicht benutzen, wenn ein Literal oder ein Identifikator benötigt wird, wie etwa bei Tabellen- oder Spaltennamen, oder in einer LIMIT-Klausel. 13 In manchen Kontexten können Sie die Zuweisung mit einem einfachen =-Zeichen vornehmen. Wir glauben allerdings, dass es besser ist, die Zweideutigkeit zu vermeiden und immer := zu benutzen.
Benutzerdefinierte Variablen | 213
• Benutzerdefinierte Variablen sind verbindungsspezifisch, eignen sich daher nicht für verbindungsübergreifende Kommunikation. • Wenn Sie Verbindungs-Pooling oder dauerhafte Verbindungen einsetzen, können sie dafür sorgen, dass scheinbar isolierte Teile Ihres Codes miteinander interagieren. • In MySQL-Versionen vor 5.0 musste für sie die Groß- und Kleinschreibung beachtet werden. Achten Sie also auf Kompatibilitätsprobleme. • Sie können die Typen dieser Variablen nicht explizit deklarieren, und die Stelle, an der die Typen für undefinierte Variablen festgelegt werden, liegt bei jeder MySQLVersion woanders. Am besten weisen Sie zu Anfang den Wert 0 für Variablen zu, die Sie für Integer-Werte einsetzen wollen, 0.0 für Gleitkommazahlen oder '' (den leeren String) für Strings. Der Typ einer Variablen ändert sich, wenn sie zugewiesen wird; die Typzuweisung für benutzerdefinierte Variablen in MySQL ist dynamisch. • Der Optimierer könnte in bestimmten Situationen diese Variablen wegoptimieren, wodurch er ihren Einsatz verhindern würde. • Die Reihenfolge der Zuweisung und sogar der Zeitpunkt der Zuweisung können nichtdeterministisch sein und hängen von dem Abfrageplan ab, den der Optimierer gewählt hat. Wie Sie später sehen werden, können die Ergebnisse sehr verwirrend sein. • Der :=-Zuweisungsoperator hat eine geringere Priorität als jeder andere Operator, Sie müssen ihn also sorgfältig einklammern. • Undefinierte Werte generieren keinen Syntaxfehler, so dass man leicht Fehler macht, ohne es zu merken. Eine der wichtigsten Eigenschaften von Variablen besteht darin, dass Sie einer Variablen einen Wert zuweisen und gleichzeitig den resultierenden Wert benutzen können. Mit anderen Worten: Eine Zuweisung ist ein L-Wert. Hier ist ein Beispiel, dass gleichzeitig eine »Zeilennummer« für eine Abfrage berechnet und ausgibt: mysql> SET @rownum := 0; mysql> SELECT actor_id, @rownum := @rownum + 1 AS rownum -> FROM sakila.actor LIMIT 3; +----------+--------+ | actor_id | rownum | +----------+--------+ | 1 | 1 | | 2 | 2 | | 3 | 3 | +----------+--------+
Dieses Beispiel ist nicht so wahnsinnig aufregend, da es einfach nur zeigt, dass wir den Primärschlüssel der Tabelle duplizieren können. Es hat aber dennoch einen Nutzen – etwa beim Ranking. Wir wollen eine Abfrage schreiben, die 10 Schauspieler zurückliefert, die in den meisten Filmen mitgespielt haben – mit einer Rangspalte, die den Schauspielern den gleichen Rang zuweist, wenn sie das gleiche Ergebnis aufweisen. Wir beginnen mit einer Abfrage, die die Schauspieler und die Anzahl der Filme ermittelt:
214 | Kapitel 4: Optimierung der Abfrageleistung
mysql> SELECT actor_id, COUNT(*) as cnt -> FROM sakila.film_actor -> GROUP BY actor_id -> ORDER BY cnt DESC -> LIMIT 10; +----------+-----+ | actor_id | cnt | +----------+-----+ | 107 | 42 | | 102 | 41 | | 198 | 40 | | 181 | 39 | | 23 | 37 | | 81 | 36 | | 106 | 35 | | 60 | 35 | | 13 | 35 | | 158 | 35 | +----------+-----+
Jetzt wollen wir den Rang hinzufügen. Alle Schauspieler, die in 35 Filmen mitgewirkt haben, sollen den gleichen Rang erhalten. Dazu verwenden wir drei Variablen: eine, um den aktuellen Rang zu verfolgen, eine, um die Filmanzahl des vorhergehenden Schauspielers aufzunehmen, und eine für die Filmanzahl des aktuellen Schauspielers. Wir ändern den Rang, wenn sich der Filmzähler ändert. Hier ist ein erster Versuch: mysql> SET @curr_cnt := 0, @prev_cnt := 0, @rank := 0; mysql> SELECT actor_id, -> @curr_cnt := COUNT(*) AS cnt, -> @rank := IF(@prev_cnt <> @curr_cnt, @rank + 1, @rank) AS rank, -> @prev_cnt := @curr_cnt AS dummy -> FROM sakila.film_actor -> GROUP BY actor_id -> ORDER BY cnt DESC -> LIMIT 10; +----------+-----+------+-------+ | actor_id | cnt | rank | dummy | +----------+-----+------+-------+ | 107 | 42 | 0 | 0 | | 102 | 41 | 0 | 0 | ...
Hoppla – Rang und Zähler stehen am Ende immer noch auf null. Wieso das denn? Es ist hier nicht möglich, eine allumfassende Antwort zu geben. Das Problem könnte ganz simpel bei einem falsch geschriebenen Variablennamen liegen (nicht in diesem Beispiel) oder etwas komplizierter sein. In diesem Fall zeigt EXPLAIN, dass es eine temporäre Tabelle und einen Filesort gibt, so dass die Variablen zu einem anderen Zeitpunkt ausgewertet werden, als wir erwartet haben. Das ist genau die Art von unergründlichem Verhalten, das Ihnen oft bei den benutzerdefinierten Variablen von MySQL begegnen wird. Das Lösen solcher Probleme kann schwer sein, zahlt sich aber wahrscheinlich wirklich aus. Das Festlegen von Rangfolgen
Benutzerdefinierte Variablen | 215
in SQL erfordert normalerweise quadratische Algorithmen, wie etwa das Zählen der Schauspieler, die in einer größeren Anzahl von Filmen mitgespielt haben. Eine Lösung mit einer benutzerdefinierten Variablen kann ein linearer Algorithmus sein – eine ziemliche Verbesserung. Eine einfache Lösung besteht in diesem Fall darin, der Abfrage eine weitere Ebene temporärer Tabellen hinzuzufügen, wobei in der FROM-Klausel eine Teilabfrage verwendet wird: mysql> SET @curr_cnt := 0, @prev_cnt := 0, @rank := 0; -> SELECT actor_id, -> @curr_cnt := cnt AS cnt, -> @rank := IF(@prev_cnt <> @curr_cnt, @rank + 1, @rank) AS rank, -> @prev_cnt := @curr_cnt AS dummy -> FROM ( -> SELECT actor_id, COUNT(*) AS cnt -> FROM sakila.film_actor -> GROUP BY actor_id -> ORDER BY cnt DESC -> LIMIT 10 -> ) as der; +----------+-----+------+-------+ | actor_id | cnt | rank | dummy | +----------+-----+------+-------+ | 107 | 42 | 1 | 42 | | 102 | 41 | 2 | 41 | | 198 | 40 | 3 | 40 | | 181 | 39 | 4 | 39 | | 23 | 37 | 5 | 37 | | 81 | 36 | 6 | 36 | | 106 | 35 | 7 | 35 | | 60 | 35 | 7 | 35 | | 13 | 35 | 7 | 35 | | 158 | 35 | 7 | 35 | +----------+-----+------+-------+
Die meisten Probleme mit benutzerdefinierten Variablen resultieren aus ihrer Zuweisung und dem Lesen der Variablen in verschiedenen Stadien der Abfrage. Zum Beispiel ist das Verhalten nicht vorhersagbar, wenn sie in der SELECT-Anweisung zugewiesen und in der WHERE-Klausel ausgelesen werden. Die folgende Abfrage scheint einfach nur eine Zeile zurückzuliefern, tut es aber nicht: mysql> SET @rownum := 0; mysql> SELECT actor_id, @rownum := @rownum + 1 AS cnt -> FROM sakila.actor -> WHERE @rownum <= 1; +----------+------+ | actor_id | cnt | +----------+------+ | 1 | 1 | | 2 | 2 | +----------+------+
216 | Kapitel 4: Optimierung der Abfrageleistung
Dies liegt daran, dass WHERE und SELECT unterschiedliche Stadien in der Abfrageausführung darstellen. Es wird noch offensichtlicher, wenn Sie mit einem ORDER BY eine weitere Stufe hinzufügen: mysql> mysql> -> -> ->
SET @rownum := 0; SELECT actor_id, @rownum := @rownum + 1 AS cnt FROM sakila.actor WHERE @rownum <= 1 ORDER BY first_name;
Diese Abfrage liefert alle Zeilen in der Tabelle zurück, weil das ORDER BY ein Filesort hinzugefügt hat und das WHERE vor dem Filesort ausgewertet wird. Die Lösung für dieses Problem besteht darin, im gleichen Stadium der Abfrageausführung zuzuweisen und zu lesen: mysql> SET @rownum := 0; mysql> SELECT actor_id, @rownum AS rownum -> FROM sakila.actor -> WHERE (@rownum := @rownum + 1) <= 1; +----------+--------+ | actor_id | rownum | +----------+--------+ | 1 | 1 | +----------+--------+
Preisfrage: Was passiert, wenn Sie das ORDER BY wieder zu dieser Abfrage hinzufügen? Probieren Sie es aus. Woran liegt es, dass Sie nicht die erwarteten Ergebnisse erhielten? Was ist mit der folgenden Abfrage, bei der das ORDER BY den Wert der Variablen ändert und die WHERE-Klausel sie auswertet? mysql> mysql> -> -> ->
SET @rownum := 0; SELECT actor_id, first_name, @rownum AS rownum FROM sakila.actor WHERE @rownum <= 1 ORDER BY first_name, LEAST(0, @rownum := @rownum + 1);
Die Antwort auf die meisten unerwarteten Verhaltensweisen von benutzerdefinierten Variablen kann man erhalten, indem man EXPLAIN ausführt und nach »Using where«, »Using temporary« oder »Using filesort« in der Extra-Spalte sucht. Das letzte Beispiel führte einen weiteren nützlichen Hack ein: Wir setzten die Zuweisung in die LEAST( )-Funktion, so dass ihr Wert gewissermaßen maskiert ist und die Ergebnisse des ORDER BY nicht stört (wie wir geschrieben haben, liefert die LEAST( )-Funktion immer 0). Dieser Trick ist sehr hilfreich, wenn Sie Variablenzuweisungen einzig wegen ihrer Nebenwirkungen durchführen wollen: Sie können damit den Rückgabewert verbergen und vermeiden das Anlegen zusätzlicher Spalten, wie der dummy-Spalte aus einem vorhergehenden Beispiel. Die Funktionen GREATEST( ), LENGTH( ), ISNULL( ), NULLIF( ), COALESCE( ) und IF( ) eignen sich ebenfalls für diesen Zweck, entweder allein oder in Kombination, da sie besondere Verhaltensweisen mitbringen. So stoppt z.B. COALESCE( ) das Auswerten seiner Argumente, sobald es einen definierten Wert annimmt.
Benutzerdefinierte Variablen | 217
Sie können Variablenzuweisungen in alle Arten von Anweisungen legen, nicht nur in SELECT-Anweisungen. Das ist sogar eine der besten Anwendungen für benutzerdefinierte Variablen. So können Sie etwa teure Abfragen, wie z.B. Rangberechnungen mit Teilabfragen, in billige UPDATE-Anweisungen umschreiben. Möglicherweise allerdings ist es nicht ganz so einfach, das gewünschte Verhalten zu erreichen. Manchmal beschließt der Optimierer, die Variablen als Konstanten zum CompileZeitpunkt zu betrachten, und lehnt es ab, Zuweisungen vorzunehmen. Meist hilft, es, die Zuweisungen in eine Funktion wie LEAST( ) zu legen. Ein anderer Tipp besteht darin, zu überprüfen, ob Ihre Variable einen definierten Wert hat, bevor die übergeordnete Anweisung ausgeführt wird. Manchmal soll sie ihn haben, dann wieder nicht. Mit ein wenig Erfahrungen können Sie alle Arten interessanter Dinge mit benutzerdefinierten Variablen erreichen. Hier sind einige Anregungen: • laufendes Berechnen von Gesamt- und Durchschnittswerten • Emulieren von FIRST( )- und LAST( )-Funktionen für gruppierte Abfragen • Berechnungen an außerordentlich großen Zahlen • Reduzieren einer ganzen Tabelle auf einen einzigen MD5-Hash-Wert • »Auspacken« eines abgefragten Wertes, der eingepackt wird, wenn er über eine bestimmte Grenze steigt • Emulieren eines Lese/Schreib-Cursors
Seien Sie vorsichtig mit MySQL-Upgrades Wir haben schon gesagt, dass es normalerweise keine gute Idee ist, wenn man versucht, den MySQL-Optimierer zu überlisten. Im Allgemeinen macht man sich damit mehr Arbeit und erhöht den Pflegeaufwand, hat aber kaum einen Nutzen davon. Das gilt vor allem, wenn Sie MySQL aufrüsten, da Optimiererhinweise, die in Ihren Abfragen verwendet werden, verhindern könnten, dass neue Optimiererstrategien zum Einsatz kommen. Die Art und Weise, wie der MySQL-Optimierer Indizes einsetzt, ist sehr unterschiedlich. Neue MySQL-Versionen ändern die Verwendung existierender Indizes, und Sie müssen Ihre Indizierungsgewohnheiten an diese neuen Versionen anpassen. Wir haben z.B. erwähnt, dass MySQL 4.0 und ältere Versionen nur einen Index pro Tabelle pro Abfrage benutzen konnten, Versionen ab MySQL 5.0 können dagegen auf Index-Merge-Strategien zurückgreifen. Abgesehen von den großen Änderungen am Abfrageoptimierer, die MySQL gelegentlich mit sich bringt, haben kleinere Versionswechsel oft viele winzige Änderungen zur Folge. Diese Änderungen betreffen üblicherweise kleine Dinge, wie etwa die Bedingungen, unter denen ein Index von der weiteren Berücksichtigung ausgeschlossen wird, und erlauben es MySQL, mehr Sonderfälle zu optimieren.
218 | Kapitel 4: Optimierung der Abfrageleistung
Das klingt zwar in der Theorie ganz gut, in der Praxis funktionieren dagegen manche Optimierungen nach einem Versionswechsel schlechter. Wenn Sie sich über einen langen Zeitraum an eine bestimmte Version gewöhnt haben, dann haben Sie wahrscheinlich – ob bewusst oder unbewusst – Ihre Abfragen genau an diese Version angepasst. Diese Optimierungen gelten möglicherweise nicht mehr für die neueren Versionen oder vermindern unter Umständen die Leistung. Falls Sie eine hohe Leistung aus Ihrem System herausholen wollen, dann sollten Sie eine Benchmark-Suite einsetzen, die Ihre spezielle Arbeitslast repräsentiert und mit der Sie die neue Version auf einem Entwicklungsserver testen können, bevor Sie Ihre Produktionsserver umstellen. Lesen Sie vor dem Aufrüsten außerdem die »Release Notes« sowie die Liste der bekannten Fehler in der neuen Version. Das MySQL-Handbuch enthält eine Liste der bekannten ernsthaften Bugs. Die meisten SQL-Upgrades bringen dennoch eine bessere Leistung mit sich, wir wollen gar nichts anderes behaupten. Seien Sie dennoch vorsichtig.
Benutzerdefinierte Variablen | 219
KAPITEL 5
Erweiterte MySQL-Funktionen
MySQL 5.0 und 5.1 führten viele Funktionen ein, wie etwa gespeicherte Prozeduren, Sichten und Trigger, die Benutzern vertraut sind, die bereits mit anderen Datenbankservern gearbeitet haben. Das Auftauchen dieser Funktionen hat MySQL viele neue Benutzer gebracht. Ihre Auswirkungen auf die Performance wurden allerdings erst deutlich, als viele Leute begannen, sie umfassend einzusetzen. Dieses Kapitel behandelt die aktuellen Ergänzungen und andere fortgeschrittene Themen, darunter einige Funktionen, die es schon in MySQL 4.1 und auch in einigen früheren Versionen gab. Wir konzentrieren uns hier auf die Performance, zeigen Ihnen aber auch, wie Sie das meiste aus diesen erweiterten Funktionen herausholen.
Der MySQL-Abfrage-Cache Viele Datenbankprodukte können Abfrageausführungspläne im Cache speichern, so dass der Server die Möglichkeit erhält, bei wiederholten Abfragen die SQL-Parsing- und Optimierungsstadien zu überspringen. MySQL kann das unter bestimmten Umständen auch, besitzt aber auch eine andere Art von Cache (den sogenannten Abfrage-Cache), der komplette Ergebnismengen für SELECT-Anweisungen speichert. Dieser Abschnitt befasst sich speziell mit diesem Cache. Der MySQL-Abfrage-Cache enthält die exakten Bits, die eine abgeschlossene Abfrage an den Client zurückgeliefert hat. Wenn ein Treffer im Abfrage-Cache auftritt, kann der Server einfach sofort die gespeicherten Ergebnisse zurückliefern und die Schritte zum Parsen, Optimieren und Ausführen überspringen. Der Abfrage-Cache behält den Überblick darüber, welche Tabellen eine Abfrage verwendet, und wenn sich eine dieser Tabellen ändert, macht er den Cache-Eintrag ungültig. Dieses Vorgehen scheint ineffektiv zu sein, da die Änderungen an den Tabellen nicht unbedingt die Ergebnisse im Cache beeinflussen müssen, es ist aber ein einfacher, relativ unaufwendiger Ansatz, was auf einem ausgelasteten System nicht ohne Bedeutung ist.
220 |
Der Abfrage-Cache ist für die Anwendung völlig transparent. Die Anwendung muss nicht wissen, ob MySQL Daten aus dem Cache zurückgeliefert oder tatsächlich die Abfrage ausgeführt hat. Das Ergebnis müsste auf jeden Fall gleich sein. Mit anderen Worten: Der Abfrage-Cache ändert die Semantik nicht; der Server scheint sich immer gleich zu verhalten, ob der Cache nun aktiviert ist oder nicht.1
Wie MySQL prüft, ob es einen Cache-Treffer gibt Die Art und Weise, wie MySQL prüft, ob es einen Treffer im Cache gibt, ist einfach und ziemlich schnell: Der Cache ist eine Lookup-Tabelle. Der Lookup-Schlüssel ist ein Hash aus dem Abfragetext selbst, der aktuellen Datenbank, der Clientprotokollversion und einer Handvoll weiterer Dinge, die die tatsächlichen Bytes im Ergebnis der Abfrage beeinflussen könnten. MySQL parst, »normalisiert« oder parametrisiert eine Anweisung nicht, wenn es nach einem Cache-Treffer sucht; stattdessen benutzt es die Anweisung und die anderen Datenbits genau so, wie der Client sie sendet. Jeder Unterschied in der Groß-/Kleinschreibung, bei den Leerzeichen oder Kommentaren – also praktisch jeder Unterschied verhindert einen erfolgreichen Vergleich mit einer zuvor im Cache gespeicherten Version. Das sollte man immer im Hinterkopf haben, wenn man Abfragen schreibt. Es ist sowieso eine gute Angewohnheit, eine konsistente Formatierung und einen einheitlichen Stil zu benutzen, in diesem Fall jedoch machen Sie damit sogar Ihr System schneller. Weiterhin speichert der Abfrage-Cache ein Ergebnis nur dann, wenn die Abfrage, die es generiert hat, deterministisch war. Das heißt, alle Abfragen, die nichtdeterministische Funktionen wie NOW( ) oder CURRENT_DATE( ) enthalten, werden nicht im Cache gespeichert. Darüber hinaus können sich Funktionen wie CURRENT_USER( ) oder CONNECTION_ID( ) unterscheiden, wenn sie von unterschiedlichen Benutzern ausgeführt werden, und verhindern auf diese Weise einen Treffer im Cache. Der Abfrage-Cache funktioniert bei Abfragen nicht, die sich auf benutzerdefinierte Funktionen, gespeicherte Funktionen, Benutzervariablen, temporäre Tabellen, Tabellen in der mysql-Datenbank oder Tabellen mit Berechtigungen auf Spaltenebene beziehen. (Im MySQL-Handbuch finden Sie eine ausführliche Liste der Dinge, die einer Cache-Speicherung im Wege stehen.) Wir hören oft Aussagen wie »MySQL prüft den Cache nicht, wenn die Abfrage eine nichtdeterministische Funktion enthält«. Das ist falsch. MySQL kann bis zum Parsen einer Abfrage nicht wissen, ob eine Abfrage eine nichtdeterministische Funktion enthält, und die Cache-Suche erfolgt vor dem Parsen. Der Server führt einen unabhängig von der Schreibweise erfolgenden Test aus, um festzustellen, dass die Abfrage mit den Buchstaben SEL beginnt, aber das ist alles.
1 Um genau zu sein, ändert der Abfrage-Cache die Semantik auf subtile Weise: Eine Abfrage kann standardmäßig aus dem Cache bedient werden, wenn eine der Tabellen, auf die sie sich bezieht, mit LOCK TABLES gesperrt ist. Sie können dies mit der Variablen query_cache_wlock_invalidate deaktivieren.
Der MySQL-Abfrage-Cache | 221
Es ist jedoch richtig zu sagen »Der Server findet keine Ergebnisse im Cache, wenn die Abfrage eine Funktion wie NOW( ) enthält«, weil der Server die Ergebnisse nicht im Cache vorliegen hat, selbst wenn er diese Abfrage schon früher ausgeführt hatte. MySQL kennzeichnet eine Abfrage als nicht-cache-fähig, sobald es ein Konstrukt entdeckt, das eine Cache-Speicherung verbietet; die Ergebnisse einer solchen Abfrage werden nicht gespeichert. Eine nützliche Technik zum Aktivieren der Cache-Speicherung von Abfragen, die sich auf das aktuelle Datum beziehen, besteht darin, das Datum als Literal einzufügen, anstatt eine Funktion zu benutzen. Zum Beispiel: ... DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY) -- Nicht-cache-fähig! ... DATE_SUB('2007-07-14', INTERVAL 1 DAY) -- Cache-fähig
Da der Abfrage-Cache auf der Ebene einer vollständigen SELECT-Anweisung arbeitet, wenn der Server sie das erste Mal von der Clientverbindung entgegennimmt, können identische Abfragen, die innerhalb einer Unterabfrage oder Sicht gemacht werden, den Abfrage-Cache nicht benutzen – ebenso wenig wie Abfragen in gespeicherten Prozeduren. Vorbereitete Anweisungen können in Versionen vor MySQL 5.1 den Abfrage-Cache ebenfalls nicht verwenden. Der MySQL-Abfrage-Cache kann die Leistung verbessern, allerdings gibt es einige Punkte, die Sie beachten sollten, wenn Sie ihn benutzen. Erstens sorgt das Aktivieren des Abfrage-Cache für zusätzlichen Aufwand beim Lesen und Schreiben: • Leseabfragen müssen vor dem Beginn den Cache überprüfen. • Wenn die Abfrage cache-fähig ist und noch nicht im Cache vorliegt, kommt es aufgrund der Speicherung des Ergebnisses nach dem Generieren zu einem gewissen Overhead. • Schließlich verursachen Schreibabfragen, die die Cache-Einträge für Abfragen ungültig machen müssen, die Tabellen benutzen, die beim Schreiben verändert werden, ebenfalls Aufwand. Dieser Overhead ist relativ gesehen minimal, der Abfrage-Cache bringt also trotzdem einen Gewinn. Allerdings: Kleinvieh macht auch Mist, wie wir später sehen werden. Für InnoDB-Benutzer besteht ein weiteres Problem darin, dass Transaktionen den Nutzen des Abfrage-Cache mindern. Wenn eine Anweisung in einer Transaktion eine Tabelle modifiziert, dann macht der Server alle im Cache gespeicherten Abfragen ungültig, die sich auf diese Tabelle beziehen, selbst wenn die InnoDB-eigene Multiversionierung die Änderungen der Transaktion vor anderen Anweisungen verbirgt. Die Tabelle ist global gesehen erst dann wieder cache-fähig, wenn die Transaktion bestätigt wird, so dass also keine weiteren Abfragen an diese Tabelle – ob außerhalb oder innerhalb dieser Transaktion – im Cache gespeichert werden können, solange die Transaktion nicht bestätigt wurde. Lange laufende Transaktionen erhöhen daher die Anzahl der fehlgeschlagenen Cache-Zugriffe.
222 | Kapitel 5: Erweiterte MySQL-Funktionen
Die zunehmende Entwertung kann bei einem großen Abfrage-Cache ebenfalls zu einem Problem werden. Wenn sich im Cache viele Abfragen befinden, kann die Entwertung lange dauern und dafür sorgen, dass das gesamte System ausgebremst wird. Das liegt daran, dass eine globale Sperre auf dem Abfrage-Cache liegt, die alle Abfragen blockiert, die auf den Cache zugreifen müssen. Der Zugriff geschieht sowohl dann, wenn auf einen Treffer geprüft wird, als auch dann, wenn geprüft wird, ob weitere Abfragen ungültig gemacht werden müssen.
Wie der Cache den Speicher benutzt MySQL legt den Abfrage-Cache vollständig im Speicher ab, Sie müssen also verstehen, wie es den Speicher benutzt, bevor Sie es richtig anpassen können. Der Cache legt in seinem Speicher mehr als nur die Abfrageergebnisse ab. Auf gewisse Weise können Sie sich das wie ein Dateisystem vorstellen: Der Cache hält Strukturen bereit, mit deren Hilfe Sie feststellen können, wie viel Speicher in seinem Pool frei ist, und er enthält Zuordnungen zwischen Tabellen und Abfrageergebnissen sowie den Abfragetext und die Abfrageergebnisse. Abgesehen von grundlegenden Verwaltungsstrukturen, die etwa 40 KByte erfordern, kann der Speicher-Pool des Abfrage-Cache in Blöcken variabler Größe benutzt werden. Jeder Block weiß, von welchem Typ er ist, welche Größe er hat und wie viele Daten er enthält. Außerdem enthält er Zeiger auf den jeweils nächsten und vorhergehenden logischen und physischen Block. Es gibt verschiedene Typen von Blöcken: Sie können Cache-Ergebnisse, Listen mit Tabellen, die von einer Abfrage benötigt werden, Abfragetext usw. speichern. Allerdings werden unterschiedliche Arten von Blöcken fast gleich behandelt, es besteht also beim Einstellen des Abfrage-Cache keine Notwendigkeit, zwischen ihnen zu unterscheiden. Wenn der Server startet, initialisiert er den Speicher für den Abfrage-Cache. Der Speicher-Pool ist anfangs ein einziger freier Block. Dieser Block ist so groß wie der gesamte Speicher, den der Cache aufgrund seiner Konfiguration belegen darf, abzüglich der Verwaltungsstrukturen. Wenn der Server die Ergebnisse einer Abfrage im Cache ablegt, reserviert er einen Block, um die Ergebnisse zu speichern. Dieser Block muss mindestens query_cache_min_res_unit Bytes groß sein, kann aber auch größer sein, wenn der Server weiß, dass er ein größeres Ergebnis speichert. Leider ist der Server nicht in der Lage, einen Block in exakt der richtigen Größe zu reservieren, da er diese anfängliche Reservierung durchführt, bevor die Ergebnismenge komplett ist. Der Server setzt die Ergebnismenge nicht im Speicher zusammen und sendet sie dann; es ist effizienter, jede Zeile dann zu senden, wenn sie generiert wird. Daraus folgt, dass der Server zu Beginn der Cache-Speicherung nicht wissen kann, wie groß die Ergebnismenge schließlich sein wird. Das Reservieren der Blöcke ist ein relativ langsamer Vorgang, weil es verlangt, dass der Server in seine Liste der freien Blöcke schaut, um einen Block zu finden, der groß genug ist. Daher versucht der Server, die Anzahl der Reservierungen, die er durchführen muss, Der MySQL-Abfrage-Cache | 223
zu minimieren. Wenn er eine Ergebnismenge im Cache speichern muss, reserviert er einen Block, der wenigstens die Minimalgröße aufweist, und beginnt damit, die Ergebnisse in diesen Block zu legen. Wird der Block voll, obwohl noch Daten vorhanden sind, die gespeichert werden müssen, belegt der Server einen neuen Block – wieder mit wenigstens der Mindestgröße – und fährt mit dem Ablegen der Daten fort. Ist das Ergebnis abgeschlossen und ist noch Platz in dem Block, dann kürzt der Server ihn auf die passende Größe und fügt den übrig gebliebenen Platz in den nachfolgenden freien Block ein. Abbildung 5-1 verdeutlicht diesen Vorgang.2 Verwaltung
Verwaltung
Verwaltung
Verwaltung
Frei Frei Frei
Anfangszustand
Speichern der Ergebnisse
Ergebnisse vollständig
Frei
Nach dem Kürzen
Cache-Block Gespeicherte Daten
Abbildung 5-1: So reserviert der Abfrage-Cache Blöcke, um ein Ergebnis zu speichern
Wenn wir sagen, dass der Server »einen Block belegt«, dann meinen wir damit nicht, dass er das Betriebssystem bittet, Speicher mit malloc( ) oder einem ähnlichen Aufruf zu reservieren. Er tut das nur einmal, wenn er den Abfrage-Cache anlegt. Wir meinen, dass der Server seine Liste der Blöcke untersucht und entweder die beste Stelle auswählt, um einen neuen Block abzulegen, oder nötigenfalls die älteste im Cache befindliche Abfrage entfernt, um Platz zu schaffen. Mit anderen Worten: Der MySQL-Server verwaltet seinen eigenen Speicher und greift dazu nicht auf das Betriebssystem zurück. Bisher ist das alles noch recht einfach. Das Bild kann allerdings deutlich komplizierter werden, als es in Abbildung 5-1 aussah. Nehmen wir an, das durchschnittliche Ergebnis ist recht klein, und der Server sendet gleichzeitig Ergebnisse an zwei Clientverbindungen. 2 Wir haben die Diagramme in diesem Abschnitt für die Darstellung vereinfacht. Die Belegung der Blöcke für den Abfrage-Cache durch den Server ist in Wirklichkeit viel komplizierter, als wir hier gezeigt haben. Falls es Sie interessiert, wie das funktioniert, schauen Sie sich die Kommentare am Anfang von sql/sql_cache.cc im Quellcode des Servers an, die das sehr gründlich erklären.
224 | Kapitel 5: Erweiterte MySQL-Funktionen
Durch das Kürzen der Ergebnisse kann ein freier Block entstehen, der kleiner ist als query_cache_min_res_unit und zum Speichern künftiger Cache-Ergebnisse nicht zu gebrauchen ist. Die Belegung der Blöcke könnte dann so aussehen wie in Abbildung 5-2. Verwaltung
Verwaltung
Verwaltung
Verwaltung Abfrage 1
Abfrage 1
Abfrage 1 Abfrage 2
Abfrage 2
Frei
Frei
Frei
Speichern der Ergebnisse
Ergebnisse vollständig
Nach dem Kürzen
Abfrage 2 Frei
Anfangszustand
Abbildung 5-2: Fragmentierung, verursacht durch das Speichern der Ergebnisse im Abfrage-Cache
Das Anpassen des ersten Ergebnisses auf die Größe hinterließ eine Lücke zwischen den beiden Ergebnissen – einen Block, der zu klein zum Ablegen eines anderen Abfrageergebnisses ist. Das Auftauchen solcher Lücken bezeichnet man als Fragmentierung. Diese bildet ein klassisches Problem bei der Speicher- und Dateisystembelegung. Fragmentierung kann aus verschiedenen Gründen auftreten, unter anderem aufgrund von Cache-Entwertungen, die Blöcke verursachen können, die für eine spätere Wiederverwendung zu klein sind.
Wann der Abfrage-Cache hilfreich ist Das Speichern von Abfragen im Cache ist nicht automatisch effizienter als das Nichtspeichern im Cache. Die Cache-Speicherung macht Arbeit, und die Ergebnisse aus dem Abfrage-Cache rentieren sich nur dann, wenn die Ersparnisse größer sind als der Aufwand. Im Prinzip hängt es von der Last auf Ihrem Server ab. Theoretisch können Sie feststellen, ob der Cache sinnvoll ist, indem Sie vergleichen, wie viel Arbeit der Server jeweils bei aktiviertem und deaktiviertem Cache verrichten muss. Bei deaktiviertem Cache muss jede Leseabfrage ausgeführt werden und ihre Ergebnisse zurückliefern, und auch alle Schreibabfragen müssen ausgeführt werden. Bei aktiviertem Cache muss jede Leseabfrage zuerst den Cache überprüfen und dann entweder das gespeicherte Ergebnis zurückliefern oder, falls es keins gibt, das Ergebnis generieren, speichern und zurückliefern. Jede Schreibabfrage muss ausgeführt werden, und anschließend muss sie überprüfen, ob im Cache Abfragen vorliegen, die entwertet werden müssen.
Der MySQL-Abfrage-Cache | 225
Das klingt zwar einfach, ist es aber nicht, da sich nicht so leicht berechnen oder vorhersagen lässt, welchen Nutzen der Abfrage-Cache abwerfen wird. Auch externe Faktoren müssen in Betracht gezogen werden. So kann z.B. der Abfrage-Cache die Zeit verringern, die erforderlich ist, bis das Ergebnis der Abfrage vorliegt, nicht jedoch die Zeit, die nötig ist, um das Ergebnis an das Clientprogramm zu senden, was der wesentliche Faktor sein könnte. Am meisten profitieren solche Abfragen von der Cache-Speicherung, die teuer in der Generierung sind, aber nicht viel Platz im Cache wegnehmen, so dass die Speicherung, die Auslieferung an den Client und die Entwertung unaufwendig sind. In diese Kategorie passen Aggregatabfragen wie kleine COUNT( )-Ergebnisse aus großen Tabellen. Es lohnt sich aber auch, andere Arten von Abfragen im Cache abzulegen. Um den Nutzen des Abfrage-Cache zu ermitteln, kann man die Trefferrate für den Abfrage-Cache untersuchen. Dabei handelt es sich um die Anzahl der Abfragen, die, anstatt vom Server ausgeführt zu werden, aus dem Cache geliefert werden. Wenn der Server eine SELECT-Anweisung empfängt, erhöht er entweder Qcache_hits oder Com_select (beides Statusvariablen), je nachdem, ob die Abfrage im Cache gelandet ist oder nicht. Die Trefferrate des Abfrage-Cache ergibt sich daher aus der Formel Qcache_hits / (Qcache_hits+Com_select). Wie sieht eine gute Cache-Trefferrate aus? Es kommt drauf an. Selbst eine Trefferrate von 30% kann hilfreich sein, da nicht ausgeführte Abfragen typischerweise (pro Abfrage) mehr Arbeit sparen als Abfragen, deren Einträge entwertet und die dann neu im Cache gespeichert werden müssen. Man sollte außerdem wissen, welche Abfragen im Cache landen. Wenn die Cache-Treffer die teuersten Abfragen repräsentieren, dann kann sogar eine niedrige Trefferrate für den Server eine Ersparnis bedeuten. Eine SELECT-Abfrage, die MySQL nicht aus dem Cache bedient, ist ein Cache-Miss (Cache-Verfehlen). Ein Cache-Miss kann aus verschiedenen Gründen auftreten: • Die Abfrage ist nicht cache-fähig, weil sie entweder ein nichtdeterministisches Konstrukt (wie etwa CURRENT_DATE) enthält oder weil ihre Ergebnismenge zu groß für die Speicherung ist. Beide Arten von nicht-cache-fähigen Abfragen erhöhen die Statusvariable Qcache_not_cached. • Der Server hat die Abfrage zuvor noch nie gesehen, hatte also keine Möglichkeit, ihr Ergebnis im Cache zu speichern. • Das Ergebnis der Abfrage wurde zuvor im Cache gespeichert, der Server hat es aber entfernt. Das kann passieren, weil der Speicher für das Ergebnis nicht ausgereicht hat, weil jemand den Server angewiesen hat, es zu entfernen, oder weil es entwertet wurde (zu Entwertungen kommen wir gleich). Wenn Ihr Server viele Cache-Misses hat, aber nur wenige nicht-cache-fähige Abfragen, dann kann das einen der folgenden Gründe haben: • Der Abfrage-Cache ist noch nicht warm. Das bedeutet, dass der Server noch keine Gelegenheit hatte, den Cache mit Ergebnismengen zu füllen.
226 | Kapitel 5: Erweiterte MySQL-Funktionen
• Der Server sieht Abfragen, die ihm vorher noch nicht begegnet sind. Falls sich kaum Abfragen bei Ihnen wiederholen, kann das passieren, obwohl der Cache warm ist. • Es gibt viele Cache-Entwertungen. Zu Cache-Entwertungen kommt es aufgrund von Fragmentierung, unzulänglichem Speicher oder Datenveränderungen. Wenn Sie für den Cache genügend Speicher belegt und den Wert query_cache_min_res_unit richtig eingestellt haben, resultieren die meisten Cache-Entwertungen aus Veränderungen an den Daten. Die Com_*-Statusvariablen (Com_update, Com_delete usw.) zeigen Ihnen, wie viele Abfragen Daten modifiziert haben, und wenn Sie die Statusvariable Qcache_lowmem_prunes überprüfen, erfahren Sie, wie viele Abfragen aufgrund mangelnden Speichers ungültig gemacht wurden. Es ist günstig, den Aufwand für die Entwertung getrennt von der Trefferrate zu betrachten. Stellen Sie sich ein extremes Beispiel vor: Sie haben eine Tabelle, die alle Leseoperationen bekommt und im Abfrage-Cache eine Trefferrate von 100 % hat, und eine weitere Tabelle, die nur Updates bekommt. Falls Sie die Trefferrate einfach aus der Statusvariablen berechnen, erhalten Sie einen Wert von 100 %. Dennoch kann der Abfrage-Cache ineffizient sein, weil er die Update-Abfragen verlangsamt. Alle Update-Abfragen müssen überprüfen, ob eine der Abfragen im Cache aufgrund ihrer Änderungen ungültig gemacht werden muss, doch da die Antwort immer »nein« lautet, ist das vergebene Liebesmüh. Sie werden ein solches Problem möglicherweise nur bemerken, wenn Sie sowohl die Anzahl der nicht-cache-fähigen Abfragen als auch die Trefferrate überprüfen. Ein Server, der einen ausgewogenen Mix aus Schreib- und cache-fähigen Lesevorgängen in den gleichen Tabellen verarbeitet, hat vermutlich auch nicht viel von einem AbfrageCache. Die Schreiboperationen entwerten laufend Ergebnisse, die im Cache vorliegen, während die cache-fähigen Leseoperationen gleichzeitig neue Ergebnisse in den Cache legen. Diese nützen nur dann etwas, wenn sie gleich im Anschluss wieder aus dem Cache ausgeliefert werden. Wenn ein im Cache gespeichertes Ergebnis entwertet wird, bevor der Server die gleiche SELECT-Anweisung noch einmal erhält, dann war das Speichern eine Zeit- und Speicherverschwendung. Schauen Sie sich die relativen Größen von Com_select und Qcache_inserts an, um festzustellen, ob dies passiert. Wenn fast jedes SELECT ein CacheMiss ist (und deshalb Com_select erhöht) und anschließend sein Ergebnis im Cache ablegt, dann ist Qcache_inserts fast so groß wie Com_select. Das heißt, Qcache_inserts sollte viel kleiner sein als Com_select, zumindest wenn der Cache richtig angewärmt ist. Jede Anwendung hat eine begrenzte potenzielle Cache-Größe, auch wenn es gar keine Schreibabfragen gibt. Die potenzielle Cache-Größe ist die Menge an Speicher, die erforderlich ist, um jede mögliche cache-fähige Abfrage zu speichern, die die Anwendung jemals ausführt. Theoretisch ist dies bei den meisten Anwendungen eine außerordentlich große Zahl. In der Praxis haben dagegen viele Anwendungen aufgrund der Anzahl der Entwertungen eine viel kleinere nutzbare Cache-Größe, als Sie vermuten würden. Selbst wenn Sie den Abfrage-Cache sehr groß machen, wird er kaum über die potenzielle Cache-Größe hinaus gefüllt werden.
Der MySQL-Abfrage-Cache | 227
Sie sollten überwachen, welchen Anteil des Abfrage-Cache Ihr Server tatsächlich benutzt. Falls er weniger Speicher verwendet, als Sie ihm zur Verfügung gestellt haben, dann verkleinern Sie ihn; falls Speicherbeschränkungen dagegen massive Entwertungen verursachen, dann machen Sie ihn größer. Machen Sie sich jedoch nicht zu große Sorgen wegen der Cache-Größe; wenn Sie den Cache ein wenig kleiner oder größer machen, als er Ihrer Meinung nach sein sollte, sind die Auswirkungen auf die Leistung nicht allzu groß. Es wird nur dann zu einem Problem, wenn viel Speicher verschwendet wird oder so viele Cache-Entwertungen auftreten, dass die Cache-Speicherung im Prinzip nutzlos wird. Sie müssen den Abfrage-Cache darüber hinaus mit den anderen Server-Caches abgleichen, wie etwa dem InnoDB-Puffer-Pool oder dem MyISAM-Schlüssel-Cache. Man kann hierfür nicht einfach ein Verhältnis oder eine einfache Formel angeben, weil die richtige Balance von der Anwendung abhängt.
Wie man den Abfrage-Cache einstellt und pflegt Wenn Sie einmal verstanden haben, wie der Abfrage-Cache funktioniert, dann ist es ganz leicht, ihn einzustellen. Er besitzt nur wenige »bewegliche Teile«: query_cache_type
Gibt an, ob der Abfrage-Cache aktiviert ist. Mögliche Werte sind OFF, ON oder DEMAND, wobei der letzte Wert bedeutet, dass nur Abfragen, die den SQL_CACHE-Modifikator enthalten, für eine Cache-Speicherung geeignet sind. Es ist sowohl eine globale Variable als auch eine Variable auf Sitzungsebene. (In Kapitel 6 erfahren Sie mehr über Sitzungs- und globale Variablen.) query_cache_size
Der Gesamtspeicher, der für den Abfrage-Cache belegt wird, in Byte. Dieser Wert muss ein Vielfaches von 1.024 Byte sein; MySQL kann hier also einen etwas anderen Wert benutzen, als Sie angegeben haben. query_cache_min_res_unit
Die minimale Größe beim Belegen eines Blocks. Wir erläuterten diese Einstellung bereits in »Wie der Cache den Speicher benutzt« auf Seite 223; sie wird im nächsten Abschnitt genauer besprochen. query_cache_limit
Die größte Ergebnismenge, die MySQL im Cache speichert. Abfragen, deren Ergebnis diese Einstellung überschreiten, gelangen nicht in den Cache. Denken Sie daran, dass der Server Ergebnisse beim Generieren im Cache ablegt, so dass er nicht im Voraus weiß, ob ein Ergebnis zu groß für den Cache wird. Wenn das Ergebnis die angegebene Grenze überschreitet, erhöht MySQL die Statusvariable Qcache_not_ cached und verwirft die Ergebnisse, die bisher in den Cache geschrieben wurden. Falls Sie wissen, dass dies oft vorkommt, können Sie den Hinweis SQL_NO_CACHE zu solchen Abfragen hinzufügen, die diesen Aufwand nicht verursachen sollen.
228 | Kapitel 5: Erweiterte MySQL-Funktionen
query_cache_wlock_invalidate
Gibt an, ob im Cache gespeicherte Ergebnisse ausgeliefert werden sollen, die sich auf Tabellen beziehen, die andere Verbindungen gesperrt haben. Der Vorgabewert lautet OFF, wodurch der Abfrage-Cache die Semantik des Servers ändert, weil er es Ihnen erlaubt, Daten aus dem Cache zu lesen, deren Tabelle von einer anderen Verbindung gesperrt wurde, was normalerweise nicht der Fall wäre. Wenn Sie diesen Wert auf ON ändern, lesen Sie zwar diese Daten nicht mehr, erhöhen aber möglicherweise die Wartezeiten auf die Sperren. Bei den meisten Anwendungen spielt das allerdings keine Rolle, so dass der Standardwert im Allgemeinen in Ordnung ist. Im Prinzip ist das Einstellen des Cache recht einfach. Komplizierter indes ist es, die Wirkungen Ihrer Änderungen zu verstehen. In den folgenden Abschnitten zeigen wir Ihnen, wie Sie den Abfrage-Cache beurteilen, um zu einer guten Entscheidung zu kommen.
Fragmentierung reduzieren Es gibt keine Möglichkeit, die Fragmentierung komplett zu vermeiden; wenn Sie jedoch den query_cache_min_res_unit-Wert sorgfältig wählen, dann tragen Sie zumindest dazu bei, dass kein Speicher im Abfrage-Cache verschwendet wird. Der Trick besteht darin, die Größe eines neuen Blocks gegen die Anzahl der Belegungen abzuwägen, die der Server durchführen muss, während er die Ergebnisse speichert. Wenn Sie diesen Wert zu klein wählen, dann verschwendet der Server weniger Speicher, muss aber die Blöcke öfter belegen, was wiederum mehr Arbeit für den Server bedeutet. Wenn Sie ihn zu groß wählen, verstärkt sich auch die Fragmentierung. Die Frage heißt also: Speicherverschwendung oder mehr CPU-Zyklen während der Zuordnung? Die beste Einstellung hängt von der Größe Ihres typischen Abfrageergebnisses ab. Sie können die durchschnittliche Größe der Abfragen im Cache ermitteln, indem Sie den verwendeten Speicher (ungefähr query_cache_size – Qcache_free_memory) durch den Wert der Statusvariablen Qcache_queries_in_cache teilen. Bei einem Mix aus großen und kleinen Ergebnissen sind Sie unter Umständen nicht in der Lage, eine Größe zu wählen, die sowohl Fragmentierung als auch zu viele Belegungen vermeidet. Sie werden aber wahrscheinlich Grund haben anzunehmen, dass es nichts bringt, die größeren Ergebnisse im Cache abzulegen. Sie können verhindern, dass große Ergebnisse im Cache gespeichert werden, indem Sie die Variable query_cache_limit verkleinern. Auf diese Weise erreichen Sie vermutlich einen besseren Ausgleich zwischen Fragmentierung und dem Aufwand, der nötig ist, um die Ergebnisse im Cache zu speichern. Eine Fragmentierung des Abfrage-Cache erkennen Sie, indem Sie die Statusvariable Qcache_free_blocks untersuchen, die Ihnen zeigt, wie viele Blöcke im Abfrage-Cache vom Typ FREE sind. In der letzten Konfiguration in Abbildung 5-2 gibt es zwei freie Blöcke. Die schlechtestmögliche Fragmentierung wäre diejenige, bei der es zwischen jedem Blockpaar, das zum Speichern von Daten verwendet wird, einen nur etwas zu kleinen freien Block gäbe, so dass jeder zweite Block ein freier Block wäre. Falls daher Qcache_free_blocks den Wert Qcache_total_blocks / 2 erreicht, ist Ihr Cache stark frag-
Der MySQL-Abfrage-Cache | 229
mentiert. Erhöht sich die Statusvariable Qcache_lowmem_prunes und haben Sie viele freie Blöcke, dann sorgt die Fragmentierung dafür, dass Abfragen vorzeitig aus dem Cache gelöscht werden. Sie können den Abfrage-Cache mit FLUSH QUERY CACHE defragmentieren. Dieser Befehl verdichtet den Abfrage-Cache, indem er alle Blöcke »nach oben« verschiebt und den freien Platz zwischen ihnen entfernt, wodurch am Ende ein einzelner freier Block übrig bleibt. Während der Ausführung blockiert der Befehl den Zugriff auf den Abfrage-Cache, wodurch praktisch der gesamte Server gesperrt wird. Wenn der Cache nicht wirklich sehr groß ist, läuft der Befehl allerdings recht schnell. Entgegen seinem Namen entfernt er keine Abfragen aus dem Cache; das erledigt RESET QUERY CACHE.
Die Verwendung des Abfrage-Cache verbessern Falls Ihr Abfrage-Cache nicht fragmentiert ist, Sie aber immer noch keine gute Trefferrate erreichen, dann haben Sie ihm möglicherweise zu wenig Speicher zugewiesen. Kann der Server keine freien Blöcke finden, die groß genug für einen neuen Block sind, muss er einige Abfragen aus dem Cache »herausschneiden«. Wenn der Server Cache-Einträge herausschneidet, erhöht er die Statusvariable Qcache_ lowmem_prunes. Steigt dieser Wert stark an, kann das einen dieser Gründe haben: • Gibt es viele freie Blöcke, dann ist wahrscheinlich die Fragmentierung schuld (siehe den vorhergehenden Abschnitt). • Gibt es weniger freie Blöcke, dann kann das bedeuten, dass bei Ihrer Arbeitslast ein größerer Cache benötigt wird, als Sie eingestellt haben. Sie ermitteln die Größe des nichtbenutzten Speichers im Cache mithilfe der Statusvariablen Qcache_free_memory. Wenn es viele freie Blöcke gibt, die Fragmentierung gering ist, es zu wenigen Kürzungen aufgrund geringen Speichers kommt und die Trefferrate immer noch niedrig ist, dann profitiert Ihre Arbeitslast möglicherweise kaum vom Cache. Irgendetwas verhindert, dass er benutzt wird. Wenn Sie viele Aktualisierungen haben, liegt es möglicherweise daran; vielleicht sind auch einfach Ihre Abfragen nicht cache-fähig. Haben Sie die Trefferrate gemessen und sind sich immer noch nicht sicher, ob der Server vom Abfrage-Cache profitiert, können Sie ihn deaktivieren und die Leistung untersuchen, ihn dann erneut aktivieren und überprüfen, ob sich die Leistung geändert hat. Um den Abfrage-Cache zu deaktivieren, setzen Sie query_cache_size auf 0. (Das globale Ändern von query_cache_type hat keinen Einfluss auf Verbindungen, die bereits geöffnet sind, und gibt dem Server den Speicher nicht zurück.) Sie können auch einen Benchmark-Test durchführen, allerdings ist es manchmal kompliziert, eine realistische Kombination aus im Cache gespeicherten Abfragen, nicht im Cache gespeicherten Abfragen und Aktualisierungen zu erhalten. Abbildung 5-3 zeigt ein Flussdiagramm mit einem einfachen Beispiel für das Vorgehen beim Analysieren und Einstellen des Abfrage-Cache Ihres Servers.
230 | Kapitel 5: Erweiterte MySQL-Funktionen
Start
Ja
Ist die Trefferrate akzeptabel?
Fertig
Nein Sind die meisten Abfragen nicht Cachefähig?
Ja
Ist query_cache_limit groß genug?
Ja
Nein
Erhöhe query_cache_limit
Nein
Gibt es viele Entwertungen?
Ja
Nein
Ist der Cache bereits aufgewärmt?
Nein
Ist der Cache fragmentiert?
Fertig. Abfragen können nicht im Cache gespeichert werden.
Ja
Verkleinere query_cache_min_res_unit oder defragmentiere mit FLUSH QUERY CACHE
Nein
Ja
Fertig. Abfragen wurden nie gesehen.
Wärmen wir den Cache auf
Wird wegen Speichermangels viel herausgeschnitten?
Ja
Vergrößere query_cache_size
Ja
Fertig. Arbeitslast eignet sich nicht für den Cache.
Nein
Gibt es viele Updates?
Nein Irgendetwas anderes ist falsch konfiguriert
Abbildung 5-3: Wie man den Abfrage-Cache analysiert und einstellt
InnoDB und der Abfrage-Cache InnoDB arbeitet aufgrund seiner MVCC-Implementierung mit dem Abfrage-Cache auf viel komplexere Art und Weise zusammen als andere Storage-Engines. In MySQL 4.0 wird der Abfrage-Cache in Transaktionen ganz und gar deaktiviert, seit MySQL 4.1 dagegen gibt InnoDB dem Server tabellenweise zu verstehen, ob eine Transaktion auf den
Der MySQL-Abfrage-Cache | 231
Abfrage-Cache zugreifen kann. Es steuert den Zugriff auf den Abfrage-Cache sowohl für Lesevorgänge (d.h. für Beziehen von Ergebnissen aus dem Cache) als auch für Schreibvorgänge (d.h. für Speichern von Ergebnissen im Cache). Faktoren, die den Zugriff bestimmen, sind die Transaktions-ID und die Frage, ob es Sperren auf der Tabelle gibt. Jede Tabelle im InnoDB-eigenen Data-Dictionary besitzt einen Transaktions-ID-Zähler. Transaktionen, deren IDs kleiner sind als der Zählerwert, dürfen bei Abfragen, die diese Tabelle betreffen, nicht aus dem Abfrage-Cache lesen oder in ihn schreiben. Auch Sperren auf einer Tabelle sorgen dafür, dass Abfragen, die auf sie zugreifen, nicht cache-fähig sind. Falls z.B. eine Transaktion eine SELECT FOR UPDATEAbfrage in einer Tabelle ausführt, dann darf für Abfragen, die diese Tabelle betreffen, keine andere Transaktion aus dem Abfrage-Cache lesen oder in ihn schreiben. Das geht erst wieder, wenn die Sperren aufgehoben wurden. Wenn die Transaktion bestätigt wird, aktualisiert InnoDB die Zähler für die Tabellen, auf die die Transaktion Sperren gelegt hat. Eine Sperre ist ein grober Anhaltspunkt dafür, ob die Transaktion die Tabelle modifiziert hat. Eine Transaktion kann Zeilen in einer Tabelle auch sperren, aber nicht aktualisieren. Es ist aber nicht möglich, dass sie den Inhalt der Tabelle modifiziert, ohne dass sie Sperren dafür anfordert. InnoDB setzt den Zähler jeder Tabelle auf die Transaktions-ID des Systems, die maximal mögliche Transaktions-ID. Das hat folgende Konsequenzen: • Der Zähler der Tabelle ist eine absolute untere Grenze, bis zu der Transaktionen den Abfrage-Cache benutzen können. Wenn die Transaktions-ID des Systems 5 ist, eine Transaktion Locks für die Zeilen in einer Tabelle beschafft und dann bestätigt wird, können die Transaktionen 1 bis 4 für Abfragen, die wieder diese Tabelle betreffen, niemals aus dem Abfrage-Cache lesen oder in ihn schreiben. • Der Zähler der Tabelle wird nicht auf die Transaktions-ID der Transaktion aktualisiert, in der die Zeilen gesperrt wurden, sondern auf die Transaktions-ID des Systems. Transaktionen, die Zeilen in Tabellen sperren, werden deshalb möglicherweise in der Zukunft bei Abfragen, die diese Tabelle betreffen, am Lesen oder Schreiben des Abschreibe-Cache gehindert. Speicherung, Abfrage und Entwertung des Abfrage-Cache geschehen auf der Serverebene. InnoDB kann das nicht umgehen oder verzögern. Allerdings kann InnoDB den Server ausdrücklich anweisen, Abfragen ungültig zu machen, die bestimmte Tabellen betreffen. Das ist notwendig, wenn eine Fremdschlüsselbeschränkung, wie etwa ON DELETE CASCADE, den Inhalt einer Tabelle verändert, die in einer Abfrage nicht erwähnt wird. Im Prinzip könnte InnoDBs MVCC-Architektur es erlauben, Abfragen aus dem Cache zu bedienen, wenn Änderungen an einer Tabelle die konsistente Lesesicht nicht beeinflussen, die andere Transaktionen sehen. Es wäre allerdings sehr kompliziert, so etwas zu implementieren. Der InnoDB-Algorithmus nimmt aus Gründen der Einfachheit Abkürzungen, auch wenn damit Transaktionen aus dem Abfrage-Cache ausgesperrt werden, obwohl das nicht unbedingt nötig wäre.
232 | Kapitel 5: Erweiterte MySQL-Funktionen
Allgemeine Abfrage-Cache-Optimierungen Viele Entscheidungen für den Schema-, Abfrage- und Anwendungsentwurf haben Einfluss auf den Abfrage-Cache. Neben den Dingen, die wir im vorhergehenden Abschnitt besprochen haben, sollten Sie Folgendes bedenken: • Es kann den Abfrage-Cache unterstützen, wenn man mehrere kleinere Tabellen anstelle einer großen Tabelle hat. Mit einem solchen Design kann man seine Entwertungsstrategie feiner ausarbeiten. Lassen Sie sich dadurch jedoch nicht übermäßig bei Ihrem Schemaentwurf beeinflussen, da andere Faktoren diesen Vorteil leicht aufwiegen können. • Es ist effizienter, Schreibvorgänge im Bündel auszuführen, da mit dieser Methode Cache-Einträge nur einmal entwertet werden. • Wir haben bemerkt, dass der Server für eine lange Zeit blockiert sein kann, während er Einträge im Abfrage-Cache entwertet oder einen sehr großen Abfrage-Cache beschneidet. Das war zumindest bis MySQL 5.1 der Fall. Eine einfache Lösung wäre es, query_cache_size nicht zu groß zu machen; etwa 256 MByte sollten mehr als genug sein. • Sie können den Abfrage-Cache nicht datenbank- oder tabellenweise kontrollieren, es ist aber möglich, einzelne Abfragen mit den Modifikatoren SQL_CACHE und SQL_NO_CACHE in die SELECT-Anweisung einzubeziehen oder aus ihr auszuschließen. Sie können den Abfrage-Cache auch für einzelne Verbindungen aktivieren oder deaktivieren, indem Sie die auf Sitzungsebene agierende Servervariable query_cache_ type auf den entsprechenden Wert setzen. • Bei einer schreibintensiven Anwendung könnten Sie eine bessere Leistung erzielen, wenn Sie den Abfrage-Cache vollständig ausschalten. Auf diese Weise werden Abfragen, die sowieso bald wieder entwertet werden, nicht erst im Cache abgelegt. Denken Sie daran, query_cache_size auf 0 zu setzen, wenn Sie ihn deaktivieren, damit der Cache keinen Speicher wegnimmt. Falls Sie den Abfrage-Cache für die meisten Abfragen weglassen wollen, dabei aber wissen, dass einige Abfragen deutlich vom Cache profitieren werden, können Sie die globale Variable query_cache_type auf DEMAND setzen und dann den Abfragen, die in den Cache gelangen sollen, den Hinweis SQL_CACHE hinzufügen. Sie haben dadurch zwar mehr Arbeit, aber auch eine exaktere Kontrolle über den Cache. Falls Sie andererseits die meisten Abfragen im Cache speichern und nur einige ausschließen wollen, können Sie ihnen SQL_NO_CACHE hinzufügen.
Alternativen zum Abfrage-Cache Der MySQL-Abfrage-Cache funktioniert nach dem Prinzip, dass die schnellste Abfrage diejenige ist, die Sie nicht ausführen müssen. Allerdings müssen Sie trotzdem die Abfrage aufrufen, und der Server bekommt auch etwas zu tun. Was wäre, wenn Sie für bestimmte Abfragen den Datenbankserver wirklich nicht ansprechen müssten? Clientseitige Cache-
Der MySQL-Abfrage-Cache | 233
Speicherung kann Ihnen helfen, die Arbeitslast auf Ihrem MySQL-Server weiter zu mindern. Mehr dazu erfahren Sie in Kapitel 10.
Code in MySQL speichern MySQL erlaubt es Ihnen, Code in Form von Triggern, gespeicherten Prozeduren und gespeicherten Funktionen innerhalb des Servers abzulegen. In MySQL 5.1 können Sie Code auch in regelmäßig wiederkehrenden Jobs, sogenannten Events, speichern. Gespeicherte Prozeduren und gespeicherte Funktionen werden zusammenfassend als »gespeicherte Routinen« bezeichnet. Alle vier Arten gespeicherten Codes benutzen eine besondere, erweiterte SQL-Sprache, die prozedurale Strukturen wie Schleifen und Bedingungen enthält.3 Der größte Unterschied zwischen den Arten gespeicherten Codes besteht in dem Kontext, in dem sie operieren – d.h. ihren Ein- und Ausgaben. Gespeicherte Prozeduren und gespeicherte Funktionen können Parameter akzeptieren und Ergebnisse zurückliefern, Trigger und Events dagegen nicht. Im Prinzip eignet sich gespeicherter Code sehr gut dazu, Code weiterzugeben und wiederzuverwenden. Giuseppe Maxia und andere haben eine Bibliothek mit allgemein einsetzbaren gespeicherten Routinen geschaffen, die Sie unter http://mysql-sr-lib.sourceforge .net finden. Es ist allerdings schwierig, gespeicherte Routinen aus anderen Datenbanksystemen wiederzuverwenden, weil die meisten ihre eigene Sprache haben (die Ausnahme ist DB2, das eine sehr ähnliche Sprache verwendet, die auf dem gleichen Standard beruht).4 Wir wollen gespeicherten Code hier nicht schreiben, sondern uns mehr auf seine Auswirkungen auf die Performance konzentrieren. Das O’Reilly-Buch MySQL Stored Procedure Programming (von Guy Harrison und Steven Feuerstein) könnte Ihnen weiterhelfen, falls Sie vorhaben, gespeicherte Prozeduren in MySQL zu schreiben. Es ist nicht schwer, sowohl Befürworter als auch Gegner gespeicherten Codes zu finden. Ohne irgendeine Partei zu ergreifen, zeigen wir hier einige der Vor- und Nachteile seines Einsatzes in MySQL. Zuerst die Vorteile: • Gespeicherter Code läuft dort, wo die Daten sind, Sie können also Bandbreite sparen und die Latenz verringern, indem Sie Aufgaben auf dem Datenbankserver ausführen. • Die Arbeit mit gespeichertem Code ist eine Form von Code-Recycling. Sie kann helfen, Geschäftsregeln zu zentralisieren, womit sich ein konsistentes Verhalten erreichen und Sicherheit und Ordnung durchsetzen lassen. 3 Die Sprache ist eine Teilmenge von SQL/PSM, dem Persistent-Stored-Modules-Teil des SQL-Standards. Sie ist in ISO/IEC 9075-4:2003 (E) definiert. 4 Es gibt außerdem einige Portierungsdienstprogramme wie etwa das tsql2mysql-Projekt (http://sourceforge.net/ projects/tsql2mysql) zum Portieren vom Microsoft SQL-Server.
234 | Kapitel 5: Erweiterte MySQL-Funktionen
• Gespeicherter Code kann Versionsstrategien und die Versionspflege erleichtern. • Er kann Sicherheitsvorteile bieten und eine Methode bereitstellen, um Rechte exakter zu kontrollieren. Ein verbreitetes Beispiel ist eine gespeicherte Prozedur für den Zahlungsverkehr in einer Bank: Die Prozedur überträgt das Geld innerhalb einer Transaktion und protokolliert die gesamte Operation für die Revision. Sie können es Anwendungen erlauben, die gespeicherte Prozedur aufzurufen, ohne Zugriff auf die zugrunde liegenden Tabellen zu gewähren. • Der Server speichert die Ausführungspläne der gespeicherten Prozedur im Cache, wodurch sich der Aufwand für wiederholte Aufrufe verringert. • Da der gespeicherte Code sich auf dem Server befindet und zusammen mit dem Server verteilt, gesichert und gewartet werden kann, ist er für Wartungsjobs geeignet. Er besitzt keine externen Abhängigkeiten, wie etwa Perl-Bibliotheken oder andere Software, die Sie lieber nicht auf den Server legen würden. • Er erlaubt die Arbeitsteilung zwischen Anwendungsentwicklern und Datenbankprogrammierern. Es könnte besser sein, wenn ein Datenbankexperte die gespeicherten Prozeduren schreibt, da nicht jeder Anwendungsprogrammierer die Fähigkeit besitzt, effiziente SQL-Abfragen zu schreiben. Zu den Nachteilen: • MySQL bietet keine guten Werkzeuge zum Entwickeln und Debuggen, weshalb es in MySQL schwieriger als in einigen anderen Datenbankservern ist, gespeicherten Code zu schreiben. • Die Sprache ist im Vergleich zu Anwendungssprachen langsam und primitiv. Die Anzahl der benutzbaren Funktionen ist eingeschränkt, und es ist schwer, komplexe Stringmanipulationen durchzuführen und eine komplexe Logik zu schreiben. • Gespeicherter Code kann das Verbreiten Ihrer Anwendung verkomplizieren. Zusätzlich zum Anwendungscode und zu den Änderungen am Datenbankschema müssen Sie auch noch Code weitergeben, der im Server gespeichert ist. • Da gespeicherte Routinen mit der Datenbank gespeichert werden, können Sie eine Sicherheitslücke schaffen. Nichtstandardisierte kryptografische Funktionen innerhalb einer gespeicherten Routine schützen z.B. Ihre Daten nicht, wenn die Datenbank kompromittiert wird. Wären die kryptografischen Funktionen im Code, müsste der Angreifer sowohl den Code als auch die Datenbank kompromittieren. • Das Speichern von Routinen verschiebt die Last auf den Datenbankserver, der typischerweise schwieriger zu skalieren ist und teurer ist als Anwendungs- oder Webserver. • MySQL bietet Ihnen nicht viel Kontrolle über die Ressourcen, die der gespeicherte Code belegen kann, so dass ein Fehler den Server zum Absturz bringen könnte. • Die MySQL-Implementierung gespeicherten Codes ist ziemlich eingeschränkt – Cache-Einträge für Ausführungspläne sind verbindungsbasiert, Cursor werden als temporäre Tabellen ausgeführt usw. (Wir gehen auf die Beschränkungen bestimmter Funktionen dann ein, wenn wir diese Funktionen beschreiben.)
Code in MySQL speichern | 235
• Es ist schwierig, Code mit gespeicherten Prozeduren in MySQL zu profilieren. Es ist schwierig, das Slow-Query-Log zu analysieren, wenn es nur CALL XYZ('A') anzeigt, weil Sie dann erst diese Prozedur suchen und sich die Anweisungen darin anschauen müssen. • Gespeicherter Code ist eine Methode, um Komplexität zu verbergen, wodurch sich die Entwicklung vereinfacht. Oft ist das aber schlecht für die Performance. Wenn Sie darüber nachdenken, gespeicherten Code zu verwenden, dann sollten Sie sich fragen, wo Sie Ihre Geschäftslogik unterbringen wollen: im Anwendungscode oder in der Datenbank? Beide Ansätze sind beliebt. Sie müssen sich nur bewusst sein, dass Sie Logik in die Datenbank setzen, wenn Sie gespeicherten Code verwenden.
Gespeicherte Prozeduren und Funktionen Die MySQL-Architektur und der Abfrageoptimierer erlegen der Art und Weise, wie Sie gespeicherte Routinen benutzen können, sowie ihrer Effizienz einige Beschränkungen auf. Momentan gelten folgende Einschränkungen: • Der Optimierer verwendet in gespeicherten Funktionen nicht den Modifikator DETERMINISTIC, um mehrfache Aufrufe innerhalb einer einzigen Abfrage wegzuoptimieren. • Der Optimierer kann momentan nicht abschätzen, wie viel es kosten wird, eine gespeicherte Funktion auszuführen. • Jede Verbindung hat ihren eigenen Ausführungsplan-Cache für gespeicherte Prozeduren. Wenn viele Verbindungen die gleiche Prozedur aufrufen, dann verschwenden sie Ressourcen, indem sie den gleichen Ausführungsplan immer wieder im Cache speichern. (Mit Verbindungs-Pooling oder persistenten Verbindungen kann der Ausführungsplan-Cache ein viel längeres nützliches Leben führen.) • Gespeicherte Routinen und Replikation sind eine verzwickte Kombination. Vermutlich wollen Sie den Aufruf der Routine nicht replizieren. Stattdessen wollen Sie die exakten Änderungen replizieren, die an Ihrer Datenmenge vorgenommen wurden. Die zeilenbasierte Replikation, die in MySQL 5.1 eingeführt wurde, hilft dabei, dieses Problem zu mildern. Wenn in MySQL 5.0 Binär-Logging aktiviert ist, wird der Server darauf bestehen, dass Sie entweder alle gespeicherten Prozeduren als DETERMINISTIC definieren oder dass Sie die mit dem komplizierten Namen log_bin_trust_ function_creators bezeichnete Serveroption aktivieren. Normalerweise halten wir gespeicherte Routinen klein und einfach. Wir führen die komplexe Logik gern außerhalb der Datenbank in einer prozeduralen Sprache aus, die vielseitig ist und größere Ausdrucksmöglichkeiten bietet. Sie kann Ihnen außerdem den Zugriff auf weitere Rechnerressourcen und potenziell sogar auf andere Formen der Cache-Speicherung bieten.
236 | Kapitel 5: Erweiterte MySQL-Funktionen
Allerdings können gespeicherte Prozeduren bei bestimmten Arten von Operationen – vor allem bei kleinen Abfragen – viel schneller sein. Wenn eine Abfrage klein genug ist, dann wird der Aufwand für das Parsen und die Kommunikation über das Netzwerk schnell zu einem wesentlichen Anteil der gesamten Arbeit, die erforderlich ist, um sie auszuführen. Um dies zu verdeutlichen, haben wir eine einfache gespeicherte Prozedur erzeugt, die eine bestimmte Anzahl von Zeilen in eine Tabelle einfügt. Hier ist der Code der Prozedur: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
DROP PROCEDURE IF EXISTS insert_many_rows; delimiter // CREATE PROCEDURE insert_many_rows (IN loops INT) BEGIN DECLARE v1 INT; SET v1=loops; WHILE v1 > 0 DO INSERT INTO test_table values(NULL,0, 'qqqqqqqqqqwwwwwwwwwweeeeeeeeeerrrrrrrrrrtttttttttt', 'qqqqqqqqqqwwwwwwwwwweeeeeeeeeerrrrrrrrrrtttttttttt'); SET v1 = v1 - 1; END WHILE; END; // delimiter ;
Mit einem Benchmark haben wir dann getestet, wie schnell diese gespeicherte Prozedur eine Million Zeilen in eine Tabelle einfügen könnte, verglichen mit dem Einfügen über eine Clientanwendung. Tabellenstruktur und Hardware sind eigentlich egal – wichtig ist die relative Geschwindigkeit der unterschiedlichen Ansätze. Nur so aus Spaß haben wir noch gemessen, wie schnell diese Abfragen ausgeführt wurden, wenn wir eine Verbindung über einen MySQL-Proxy verwendeten. Aus Gründen der Einfachheit führten wir den gesamten Benchmark auf einem einzigen Server aus, der sowohl die Clientanwendung als auch die MySQL-Proxy-Instanz enthielt. Tabelle 5-1 zeigt die Ergebnisse. Tabelle 5-1: Gesamtzeit für das Nacheinandereinfügen von einer Million Zeilen Methode
Gesamtzeit
Gespeicherte Prozedur
101 sek.
Clientanwendung
279 sek.
Clientanwendung mit MySQL-Proxy
307 sek.
Die gespeicherte Prozedur ist viel schneller. Das liegt hauptsächlich daran, dass sie den Aufwand für die Netzwerkkommunikation, das Parsen, Optimieren usw. vermeidet. Wir zeigen in »Die SQL-Schnittstelle für vorbereitete Anweisungen« auf Seite 245 eine typische gespeicherte Prozedur für Wartungsjobs.
Code in MySQL speichern | 237
Trigger Trigger erlauben es Ihnen, Code auszuführen, wenn eine INSERT-, UPDATE- oder DELETEAnweisung vorhanden ist. Sie können MySQL anweisen, sie auszuführen, bevor und/oder nachdem die auslösende Anweisung ausgeführt wurde. Sie können keine Werte zurückliefern, lesen und/oder ändern, wohl aber die Daten, die die triggernde Anweisung ändert. Aus diesem Grund können Sie Trigger einsetzen, um Randbedingungen oder eine Geschäftslogik durchzusetzen, die Sie ansonsten in den Clientcode schreiben müssten. Ein gutes Beispiel ist das Emulieren von Fremdschlüsseln in einer StorageEngine, die diese nicht unterstützt, wie z.B. MyISAM. Trigger können die Anwendungslogik vereinfachen und die Performance verbessern, da sie den Wechsel zwischen Client und Server sparen. Sie können außerdem beim automatischen Aktualisieren von denormalisierten Tabellen und Summary-Tabellen hilfreich sein. So verwendet sie z.B. die Sakila-Beispieldatenbank zum Pflegen der Tabelle film_text. Die MySQL-Trigger-Implementierung ist momentan noch nicht sehr umfangreich. Gehen Sie nicht davon aus, dass Sie Trigger genauso umfassend einsetzen können, wie Sie es möglicherweise von einem anderen Datenbankprodukt her gewöhnt sind: • Sie können für jedes Event nur einen Trigger pro Tabelle haben. (Mit anderen Worten: Sie können nicht zwei Trigger haben, die AFTER INSERT auslösen.) • MySQL unterstützt nur Trigger auf Zeilenebene – d.h., Trigger operieren immer FOR EACH ROW (sozusagen für jede Zeile einzeln) anstatt für die Anweisung als Ganzes. Für die Verarbeitung großer Datenmengen ist das nicht besonders effizient. Beachten Sie außerdem die folgenden allgemeinen Warnungen für Trigger in MySQL: • Trigger können verschleiern, was Ihr Server wirklich macht, da eine einzige Anweisung dafür sorgen kann, dass der Server eine Menge »unsichtbarer Arbeit« verrichtet. Falls z.B. ein Trigger eine verwandte Tabelle aktualisiert, kann es passieren, dass er die Anzahl der Zeilen verdoppelt, die eine Anweisung beeinflusst. • Es kann schwierig sein, Fehler in Triggern zu finden, und oft ist es schwer, Leistungsengpässe zu analysieren, wenn Trigger beteiligt sind. • Trigger können Deadlocks und Wartezeiten auf Sperren verursachen, die nicht offensichtlich sind. Wenn ein Trigger fehlschlägt, dann wird auch aus der ursprünglichen Abfrage nichts, und falls Ihnen gar nicht bewusst ist, dass ein Trigger existiert, werden Sie vermutlich Probleme haben, den Fehlercode zu entziffern. Bezüglich der Leistung ist das FOR EACH ROW-Design die stärkste Einschränkung der MySQL-Trigger-Implementierung. Es ist dafür verantwortlich, dass es manchmal recht unpraktisch ist, Trigger zum Pflegen von Summary- und Cache-Tabellen einzusetzen, weil sie zu langsam sein könnten. Der Hauptgrund für die Verwendung von Triggern anstelle einer regelmäßig wiederkehrenden Massenaktualisierung ist, dass mit Triggern Ihre Daten immer konsistent sind.
238 | Kapitel 5: Erweiterte MySQL-Funktionen
Trigger garantieren außerdem keine Atomizität. So kann z.B. ein Trigger, der eine MyISAM-Tabelle aktualisiert, nicht zurückgenommen werden, wenn in der Anweisung, die den Trigger auslöst, ein Fehler auftritt. Auch ein Trigger könnte einen Fehler verursachen. Nehmen Sie an, dass Sie einen AFTER UPDATE-Trigger an eine MyISAM-Tabelle anhängen und ihn verwenden, um eine andere MyISAM-Tabelle zu aktualisieren. Wenn der Trigger einen Fehler hat, der das Update der zweiten Tabelle scheitern lässt, wird das Update der ersten Tabelle nicht rückgängig gemacht. Trigger in InnoDB-Tabellen operieren innerhalb derselben Transaktion, so dass die Aktionen, die sie unternehmen, zusammen mit der Anweisung, die sie ausgelöst hat, atomar sind. Falls Sie jedoch mit InnoDB einen Trigger verwenden, um die Daten einer anderen Tabelle zu überprüfen, wenn Sie eine Beschränkung validieren, dann denken Sie an MVCC, da Sie ansonsten falsche Ergebnisse erhalten könnten. Nehmen Sie z.B. an, Sie wollen Fremdschlüssel emulieren, wollen jedoch nicht die InnoDB-Fremdschlüssel benutzen. Sie können einen BEFORE INSERT-Trigger schreiben, der die Existenz eines passenden Datensatzes in einer anderen Tabelle überprüft. Falls Sie allerdings beim Lesen aus der anderen Tabelle nicht SELECT FOR UPDATE in dem Trigger wählen, können nebenläufige Updates an dieser Tabelle unkorrekte Ergebnisse verursachen. Wir wollen Ihnen die Benutzung von Triggern jedoch nicht vermiesen. Im Gegenteil, sie können sehr nützlich sein, speziell für Beschränkungen, Systempflegeaufgaben und zum Synchronisieren von denormalisierten Daten. Sie können Trigger außerdem benutzen, um Änderungen an Zeilen zu protokollieren. Das ist z.B. praktisch für eigene Replikationseinrichtungen, bei denen Sie Systeme trennen, Daten ändern und die Änderungen dann wieder zusammenführen wollen. Betrachten Sie etwa eine Gruppe von Benutzern, die ihre Laptops mit zur Arbeit nehmen. Deren Änderungen müssen mit einer Master-Datenbank synchronisiert werden. Anschließend müssen die Master-Daten wieder zurück auf die einzelnen Laptops kopiert werden. Um dies zu erreichen, ist eine Zweiwegesynchronisation erforderlich. Trigger bieten eine gute Möglichkeit, solche Systeme aufzubauen. Jeder Laptop kann Trigger verwenden, um alle Datenmodifikationen in Tabellen zu protokollieren, die anzeigen, welche Zeilen geändert worden sind. Das eigene Synchronisationswerkzeug kann dann diese Änderungen auf die Master-Datenbank anwenden. Schließlich kann dann eine ganz normale MySQL-Replikation die Laptops mit dem Master synchronisieren, der die Änderungen von all den Laptops hat. Manchmal ist es sogar möglich, die FOR EACH ROW-Einschränkung zu umgehen. Roland Bouman hat festgestellt, dass ROW_COUNT( ) innerhalb eines Triggers immer 1 zurückgibt, mit Ausnahme der ersten Zeile eines BEFORE-Triggers. Diese Tatsache können Sie nutzen, um zu verhindern, dass der Code des Triggers bei jeder betroffenen Zeile ausgeführt wird, und um ihn nur einmal pro Anweisung auszuführen. Das ist nicht das Gleiche wie ein anweisungsbezogener Trigger, bietet aber die Möglichkeit, in einigen Fällen einen anweisungsbezogenen BEFORE-Trigger zu emulieren. Dieses Verhalten ist vielleicht ein Bug, den es irgendwann einmal nicht mehr geben wird. Seien Sie also vorsichtig, wenn
Code in MySQL speichern | 239
Sie darauf zurückgreifen, und vergewissern Sie sich, dass es nach einem Aufrüsten des Servers noch vorhanden ist. Setzen Sie diesen Hack z.B. so ein: CREATE TRIGGER fake_statement_trigger BEFORE INSERT ON sometable FOR EACH ROW BEGIN DECLARE v_row_count INT DEFAULT ROW_COUNT( ); IF v_row_count <> 1 THEN -- Ihr Code END IF; END;
Events Events sind eine neue Form gespeicherten Codes in MySQL 5.1. Sie gleichen cron-Jobs, befinden sich aber vollkommen im MySQL-Server. Man kann Events erzeugen, die SQLCode einmal zu einem angegebenen Zeitpunkt oder öfter in einem angegebenen Intervall ausführen. Das übliche Vorgehen sieht so aus, dass das komplexe SQL in einer gespeicherten Prozedur verpackt wird, so dass das Event lediglich einen CALL ausführen muss. Events werden in einem separaten Event-Scheduler-Thread ausgeführt, weil sie nichts mit den Verbindungen zu tun haben. Sie nehmen keine Eingaben entgegen und geben keine Werte zurück – es gibt für sie keine Verbindungen, über die sie Eingaben erhalten oder Werte zurückliefern könnten. Sie können im Server-Log – falls es aktiviert ist – die Befehle sehen, die sie ausführen, es lässt sich aber oft nur schwer feststellen, dass diese Befehle von einem Event ausgeführt wurden. Mithilfe der INFORMATION_SCHEMA.EVENTSTabelle ermitteln Sie den Status eines Events, wie etwa den letzten Zeitpunkt, zu dem es ausgeführt wurde. Für Events gelten ähnliche Überlegungen wie für gespeicherte Prozeduren: Sie verursachen dem Server zusätzliche Arbeit. Der Aufwand für das Event selbst ist minimal, allerdings kann das SQL, das es aufruft, ernste Auswirkungen auf die Leistung haben. Gute Anwendungen für Events sind unter anderem regelmäßig ausgeführte Wartungsarbeiten, der Neuaufbau von Cache- und Summary-Tabellen zum Emulieren von materialisierten Sichten oder das Speichern von Statuswerten für Überwachung und Diagnose. Das folgende Beispiel erzeugt ein Event, das einmal in der Woche eine gespeicherte Prozedur für eine bestimmte Datenbank ausführt:5 CREATE EVENT optimize_somedb ON SCHEDULE EVERY 1 WEEK DO CALL optimize_tables('somedb');
Sie können festlegen, ob Events auf Slave-Server repliziert werden sollen. Manchmal ist das angebracht, in anderen Fällen wiederum nicht. Nehmen Sie etwa das gezeigte Beispiel: Wahrscheinlich wollen Sie die Operation OPTIMIZE TABLE auf allen Slaves ausführen. 5 Wir zeigen Ihnen später, wie Sie diese gespeicherte Prozedur erzeugen.
240 | Kapitel 5: Erweiterte MySQL-Funktionen
Denken Sie allerdings daran, dass dies die Gesamtleistung des Servers beeinträchtigen könnte (z.B. mit Tabellen-Locks), wenn alle Slaves diese Operation gleichzeitig ausführen würden. Und falls schließlich ein periodisch wiederkehrendes Event lange braucht, bis es abgeschlossen ist, könnte es passieren, dass das Event schon wieder ausgelöst wird, obwohl seine vorhergehende Instanz noch läuft. MySQL bietet davor keinen Schutz, so dass Sie einen eigenen Code schreiben müssen, der so etwas ausschließt. Sie könnten z.B. GET_LOCK( ) einsetzen, um sicherzustellen, dass immer nur ein Event ausgeführt wird: CREATE EVENT optimize_somedb ON SCHEDULE EVERY 1 WEEK DO BEGIN DECLARE CONTINUE HANDLER FOR SQLEXCEPTION BEGIN END; IF GET_LOCK('somedb', 0) THEN DO CALL optimize_tables('somedb'); END IF; DO RELEASE_LOCK('somedb'); END
Der »Dummy«-Continue-Handler stellt sicher, dass das Event die Sperre sogar dann freigibt, wenn die gespeicherte Prozedur eine Ausnahme auslöst. Events haben zwar nichts mit Verbindungen zu tun, sind aber mit Threads verknüpft. Es gibt einen Haupt-Event-Scheduler-Thread, den Sie in der Konfigurationsdatei Ihres Servers oder mit einem SET-Befehl aktivieren müssen: mysql> SET GLOBAL event_scheduler := 1;
Wenn dieser Thread aktiviert ist, erzeugt er zum Ausführen jedes Events einen neuen Thread. Innerhalb des Event-Codes liefert ein Aufruf von CONNECTION_ID( ) wie üblich einen eindeutigen Wert zurück – auch wenn es eigentlich keine »Verbindung« gibt. (Der Rückgabewert von CONNECTION_ID( ) ist tatsächlich nur die Thread-ID.) Sie können im Fehler-Log des Servers nach Informationen über die Ausführung von Events suchen.
Kommentare in gespeichertem Code schützen Gespeicherte Prozeduren, gespeicherte Funktionen, Trigger und Events können jeweils große Mengen Code enthalten, so dass es praktisch unerlässlich ist, diesen mit Kommentaren zu versehen. Allerdings sollten die Kommentare nicht innerhalb des Servers gespeichert werden, da der Kommandozeilenclient sie möglicherweise entfernt. (Diese Eigenart des Kommandozeilenclients ist wirklich ein Ärgernis, aber hey, c’est la vie.) Ein hilfreicher Trick, um die Kommentare in Ihrem gespeicherten Code zu schützen, ist die Verwendung von versionsspezifischen Kommentaren, die der Server als potenziell ausführbaren Code betrachtet (d.h. als Code, der nur dann ausgeführt wird, wenn die Versionsnummer des Servers dieser oder einer höheren Version entspricht). Server- und Clientprogramme wissen, dass dies keine einfachen Kommentare sind, und verwerfen sie
Code in MySQL speichern | 241
deshalb nicht. Um zu verhindern, dass der »Code« ausgeführt wird, benutzen Sie einfach eine sehr hohe Versionsnummer, wie etwa 99999. Wir wollen z.B. hier unser Trigger-Beispiel ein wenig dokumentieren, um den Schleier etwas zu lüften: CREATE TRIGGER fake_statement_trigger BEFORE INSERT ON irgendeine_tabelle FOR EACH ROW BEGIN DECLARE v_row_count INT DEFAULT ROW_COUNT( ); /*!99999 ROW_COUNT( ) ist 1 ausser fuer die erste Zeile, so dass dies nur einmal pro Anweisung ausgefuehrt wird. */ IF v_row_count <> 1 THEN -- Hier kommt Ihr Code hin END IF; END;
Cursor MySQL bietet momentan schreibgeschützte, vorwärtsgerichtete, serverseitige Cursor, die Sie nur aus einer gespeicherten MySQL-Prozedur heraus benutzen können. Sie erlauben es Ihnen, Abfrageergebnisse Zeile für Zeile durchzugehen und alle Zeilen zur weiteren Verarbeitung in Variablen zu bringen. Eine gespeicherte Prozedur kann gleichzeitig mehrere Cursor offen halten. Außerdem können Sie Cursor in Schleifen »schachteln«. In Zukunft könnte MySQL Cursor anbieten, die sich aktualisieren lassen, in aktuellen Versionen gibt es sie jedoch noch nicht. Cursor sind schreibgeschützt, d.h., lassen sich nur lesen, weil sie über temporäre Tabellen iterieren und nicht über die Tabellen, aus denen die Daten eigentlich stammen. Das Cursordesign von MySQL hält für unachtsame Anwender einige Fallstricke bereit. Da Cursor mit temporären Tabellen implementiert werden, bieten sie den Entwicklern ein falsches Gefühl von Effizienz. Das Wichtigste, was Sie wissen müssen, ist, dass ein Cursor die gesamte Abfrage ausführt, wenn Sie ihn öffnen. Betrachten Sie folgende Prozedur: 1 CREATE PROCEDURE bad_cursor( ) 2 BEGIN 3 DECLARE film_id INT; 4 DECLARE f CURSOR FOR SELECT film_id FROM sakila.film; 5 OPEN f; 6 FETCH f INTO film_id; 7 CLOSE f; 8 END
Dieses Beispiel zeigt, dass Sie einen Cursor schließen können, bevor Sie alle seine Ergebnisse durchlaufen. Ein Entwickler, der an Oracle oder Microsoft SQL Server gewöhnt ist, sieht möglicherweise nichts Falsches in dieser Prozedur, in MySQL verursacht sie hingegen eine Menge unnützer Arbeit. Wenn Sie diese Prozedur mit SHOW STATUS profilieren,
242 | Kapitel 5: Erweiterte MySQL-Funktionen
dann sehen Sie, dass sie 1.000 Indexlesevorgänge und 1.000 Einfügeoperationen durchführt. Das liegt daran, dass 1.000 Zeilen in sakila.film stehen. Alle 1.000 Lese- und Schreibvorgänge geschehen, wenn Zeile 5 und bevor Zeile 6 ausgeführt wird. Die Moral von der Geschicht’ lautet, dass Sie eigentlich keine Arbeit sparen, wenn Sie einen Cursor, der Daten aus einer großen Ergebnismenge holt, frühzeitig schließen. Falls Sie wirklich nur einige Zeilen benötigen, dann verwenden Sie LIMIT. Cursor können außerdem dafür sorgen, dass MySQL zusätzliche Ein-/Ausgabeoperationen ausführt, und sie können sehr langsam sein. Da temporäre Tabellen, die im Speicher liegen, die Typen BLOB und TEXT nicht unterstützen, muss MySQL für Cursor über Ergebnisse mit diesen Typen eine temporäre Tabelle auf der Festplatte anlegen. Und auch wenn diese Typen nicht enthalten sind, erzeugt MySQL die temporäre Tabelle auf der Festplatte, nämlich dann, wenn diese Tabelle größer als tmp_table_size ist. MySQL unterstützt keine clientseitigen Cursor, allerdings enthält die Client-API Funktionen, die clientseitige Cursor emulieren, indem sie das gesamte Ergebnis in den Speicher holen. Das ist eigentlich nichts anderes, als wenn Sie das Ergebnis in ein Array in Ihrer Anwendung setzen und es dort manipulieren. In »Das MySQL-Client/Server-Protokoll« auf Seite 173 erfahren Sie mehr darüber, welche Auswirkungen es auf die Leistung hat, wenn Sie das gesamte Ergebnis in den clientseitigen Speicher holen.
Vorbereitete Anweisungen MySQL 4.1 und neuere Versionen unterstützen serverseitige vorbereitete Anweisungen, die ein verbessertes binäres Client/Server-Protokoll verwenden, um Daten effizient zwischen Client und Server hin- und herzuschicken. Sie greifen auf die Funktionalität der vorbereiteten Anweisungen über eine Programmierbibliothek zu, die das neue Protokoll unterstützt, wie etwa die MySQL-C-API. Die Bibliotheken MySQL Connector/J und MySQL Connector/NET bieten die gleichen Fähigkeiten wie Java bzw. .NET. Es gibt außerdem eine SQL-Schnittstelle für vorbereitete Anweisungen, auf die wir später eingehen. Wenn Sie eine vorbereitete Anweisung anlegen, sendet die Clientbibliothek dem Server einen Prototyp der eigentlichen Abfrage, die Sie benutzen wollen. Der Server analysiert und verarbeitet dieses Abfrage-»Skelett«, speichert eine Struktur, die die teilweise optimierte Abfrage repräsentiert, und gibt ein Anweisungs-Handle an den Client zurück. Die Clientbibliothek kann die Abfrage dann wiederholt ausführen, indem sie das Anweisungs-Handle angibt. Vorbereitete Anweisungen können Parameter haben, bei denen es sich um Platzhalter in Form von Fragezeichen für Werte handelt, die Sie angeben, wenn Sie die Anweisung ausführen. So könnten Sie die folgende Abfrage vorbereiten: mysql> INSERT INTO tbl(col1, col2, col3) VALUES (?, ?, ?) ;
Vorbereitete Anweisungen | 243
Sie führen diese Abfrage dann aus, indem Sie das Anweisungs-Handle an den Server senden und dabei Werte für die einzelnen Platzhalter mitliefern. Das können Sie dann so oft wiederholen, wie Sie wollen. Wie genau Sie das Anweisungs-Handle an den Server senden, hängt von Ihrer Programmiersprache ab. Eine Möglichkeit besteht darin, die MySQL-Konnektoren für Java und .NET zu benutzen. Viele Clientbibliotheken, die mit den MySQL-C-Bibliotheken verknüpft sind, bieten ebenfalls irgendeine Schnittstelle zum Binärprotokoll. Lesen Sie einfach die Dokumentation Ihrer MySQL-API. Aus verschiedenen Gründen kann es effizienter sein, vorbereitete Anweisungen zu verwenden, als eine Abfrage wiederholt auszuführen: • Der Server muss die Abfrage nur einmal analysieren, was das Parsen und einige andere Dinge spart. • Der Server muss einige Schritte zur Abfrageoptimierung nur einmal durchführen, da er einen teilweisen Abfrageausführungsplan im Cache ablegt. • Die Parameter über das Binärprotokoll zu senden ist effizienter als das Senden als ASCII-Text. So kann z.B. ein DATE-Wert in nur 3 Bytes gesendet werden und benötigt nicht 10 Bytes wie in ASCII. Die größten Ersparnisse gibt es für BLOB- und TEXTWerte, die in Stücken anstatt in einem riesigen Datenbatzen gesendet werden können. Das Binärprotokoll spart daher auch Speicher auf dem Client, reduziert den Netzwerkverkehr und den Aufwand beim Konvertieren zwischen dem dateneigenen Speicherformat und dem Format des nichtbinären Protokolls. • Zur jeweiligen Ausführung müssen nur die Parameter und nicht der gesamte Abfragetext gesendet werden, was den Netzwerkverkehr ebenfalls verringert. • MySQL speichert die Parameter direkt in Puffern auf dem Server. Der Server muss deshalb die Werte nicht im Speicher herumkopieren. Vorbereitete Anweisungen sind darüber hinaus gut für die Sicherheit. Es ist nicht notwendig, Werte in der Anwendung zu schützen oder zu quotieren. Das ist bequem und verkleinert die Gefahr durch SQL-Injection und andere Angriffe. (Sie dürfen niemals einer Benutzereingabe vertrauen, selbst wenn Sie vorbereitete Anweisungen verwenden.) Sie können das Binärprotokoll nur mit vorbereiteten Anweisungen einsetzen. Werden Abfragen über die normale mysql_query( )-API-Funktion aufgerufen, kommt nicht das Binärprotokoll zum Einsatz. Viele Clientbibliotheken erlauben es Ihnen, Anweisungen mit Fragezeichenplatzhaltern »vorzubereiten« und geben dann die Werte für jede Ausführung an. Allerdings emulieren diese Bibliotheken häufig nur den Vorbereiten-Ausführen-Zyklus im clientseitigen Code und senden eigentlich jede Abfrage mit mysql_query( ) an den Server.
Optimierung von vorbereiteten Anweisungen MySQL legt teilweise Abfrageausführungspläne für vorbereitete Anweisungen im Cache ab. Allerdings sind manche Optimierungen von den tatsächlichen Werten abhängig, die an die einzelnen Parameter gebunden sind, und können deshalb nicht vorab berechnet
244 | Kapitel 5: Erweiterte MySQL-Funktionen
und im Cache gespeichert werden. Man kann die Optimierungen in drei Typen unterteilen, die jeweils darauf basieren, wann sie ausgeführt werden müssen. Die folgende Liste ist zurzeit gültig, kann sich aber künftig ändern: Zum Vorbereitungszeitpunkt Der Server analysiert den Abfragetext, eliminiert Negationen und schreibt Unterabfragen um. Bei der ersten Ausführung Der Server vereinfacht geschachtelte Joins und wandelt OUTER JOIN in INNER JOIN um, wo das möglich ist. Bei jeder Ausführung Der Server tut Folgendes: • Er kürzt Partitionen. • Er eliminiert COUNT( ), MIN( ) und MAX( ), wo das möglich ist. • Er entfernt konstante Unterausdrücke. • Er sucht konstante Tabellen. • Er propagiert Gleichheiten. • Er analysiert und optimiert die Zugriffsmethoden ref, range und index_merge. • Er optimiert die Join-Reihenfolge. In Kapitel 4 finden Sie mehr Informationen über diese Optimierungen.
Die SQL-Schnittstelle für vorbereitete Anweisungen Es gibt seit MySQL 4.1 eine SQL-Schnittstelle für vorbereitete Anweisungen. Hier ist ein Beispiel dafür, wie Sie eine vorbereitete Anweisung über SQL ansprechen: mysql> SET @sql := 'SELECT actor_id, first_name, last_name -> FROM sakila.actor WHERE first_name = ?'; mysql> PREPARE stmt_fetch_actor FROM @sql; mysql> SET @actor_name := 'Penelope'; mysql> EXECUTE stmt_fetch_actor USING @actor_name; +----------+------------+-----------+ | actor_id | first_name | last_name | +----------+------------+-----------+ | 1 | PENELOPE | GUINESS | | 54 | PENELOPE | PINKETT | | 104 | PENELOPE | CRONYN | | 120 | PENELOPE | MONROE | +----------+------------+-----------+ mysql> DEALLOCATE PREPARE stmt_fetch_actor;
Wenn der Server diese Anweisungen empfängt, übersetzt er sie in die gleichen Operationen, die auch von der Clientbibliothek aufgerufen worden wären. Das bedeutet, dass Sie nicht das spezielle Binärprotokoll benutzen müssen, um vorbereitete Anweisungen zu erzeugen und auszuführen.
Vorbereitete Anweisungen | 245
Wie Sie sehen können, ist die Syntax etwas seltsamer, verglichen mit einer einfachen, direkten SELECT-Anweisung. Worin besteht also der Vorteil, wenn Sie eine vorbereitete Anweisung auf diese Weise einsetzen? Der wichtigste Anwendungsfall sind gespeicherte Prozeduren. In MySQL 5.0 können Sie vorbereitete Anweisungen in gespeicherten Prozeduren benutzen; die Syntax ähnelt derjenigen der SQL-Schnittstelle. Das bedeutet, dass Sie »dynamisches SQL« in gespeicherten Prozeduren aufbauen und ausführen können, indem Sie Strings aneinanderhängen. Die gespeicherten Prozeduren werden dadurch viel flexibler. Hier sehen Sie z.B. eine gespeicherte Prozedur, die OPTIMIZE TABLE in jeder Tabelle in einer angegebenen Datenbank aufrufen kann: DROP PROCEDURE IF EXISTS optimize_tables; DELIMITER // CREATE PROCEDURE optimize_tables(db_name VARCHAR(64)) BEGIN DECLARE t VARCHAR(64); DECLARE done INT DEFAULT 0; DECLARE c CURSOR FOR SELECT table_name FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = db_name AND TABLE_TYPE = 'BASE TABLE'; DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = 1; OPEN c; tables_loop: LOOP FETCH c INTO t; IF done THEN CLOSE c; LEAVE tables_loop; END IF; SET @stmt_text := CONCAT("OPTIMIZE TABLE ", db_name, ".", t); PREPARE stmt FROM @stmt_text; EXECUTE stmt; DEALLOCATE PREPARE stmt; END LOOP; CLOSE c; END// DELIMITER ;
Sie können diese gespeicherte Prozedur folgendermaßen anwenden: mysql> CALL optimize_tables('sakila');
Hier ist eine andere Möglichkeit, die Schleife in der Prozedur zu schreiben: REPEAT FETCH c INTO t; IF NOT done THEN SET @stmt_text := CONCAT("OPTIMIZE TABLE ", db_name, ".", t); PREPARE stmt FROM @stmt_text; EXECUTE stmt; DEALLOCATE PREPARE stmt; END IF; UNTIL done END REPEAT;
246 | Kapitel 5: Erweiterte MySQL-Funktionen
Es gibt einen wichtigen Unterschied zwischen den beiden Schleifenkonstrukten: REPEAT prüft für jede Schleife zweimal die Schleifenbedingung. Das verursacht in diesem Beispiel wahrscheinlich kein großes Performance-Problem, da wir hier lediglich den Wert eines Integers überprüfen. Es könnte bei komplexeren Tests allerdings kostenintensiver werden. Das Verketten von Strings, um auf Tabellen und Datenbanken zu verweisen, ist eine gute Anwendung für die SQL-Schnittstelle in vorbereiteten Anweisungen, da Sie damit Anweisungen schreiben können, die nicht mit Parametern arbeiten. Man kann Datenbank- und Tabellennamen nicht parametrisieren, weil es sich hierbei um Identifikatoren handelt. Ein anderes Szenario ist das dynamische Einstellen einer LIMIT-Klausel, die Sie ebenfalls nicht mit einem Parameter angeben können. Die SQL-Schnittstelle eignet sich zum manuellen Testen einer vorbereiteten Anweisung, außerhalb von gespeicherten Prozeduren ist sie dagegen nicht so nützlich. Da die Schnittstelle über SQL agiert, benutzt sie nicht das Binärprotokoll. Außerdem sorgt sie kaum für eine Verringerung des Netzwerkverkehrs, weil man zusätzliche Abfragen aufrufen muss, um die Variablen einzustellen, wenn es Parameter gibt. In besonderen Fällen können Sie davon profitieren, diese Schnittstelle zu benutzen, etwa wenn Sie einen riesigen SQLString vorbereiten, den Sie sehr oft ohne Parameter ausführen werden. Allerdings sollten Sie auf jeden Fall einen Benchmark-Test durchführen, wenn Sie der Meinung sind, dass der Einsatz der SQL-Schnittstelle für vorbereitete Anweisungen Ihnen Arbeit erspart.
Die Grenzen vorbereiteter Anweisungen Für vorbereitete Anweisungen gelten einige Grenzen und Warnungen: • Vorbereitete Anweisungen gehören lokal zu einer Verbindung. Eine andere Verbindung kann also nicht das gleiche Handle benutzen. Aus dem gleichen Grund verliert ein Client, der eine Verbindung schließt und anschließend neu etabliert, die Anweisungen. (Verbindungs-Pooling oder persistente Verbindungen können dieses Problem mildern.) • In MySQL-Versionen vor 5.1 können vorbereitete Anweisungen den MySQLAbfrage-Cache nicht benutzen. • Es ist nicht immer effizienter, vorbereitete Anweisungen zu verwenden. Wenn Sie eine vorbereitete Anweisung nur einmal benutzen, dann benötigen Sie wahrscheinlich mehr Zeit für die Vorbereitung, als wenn Sie sie einfach als normales SQL einsetzen würden. Das Vorbereiten einer Anweisung erfordert darüber hinaus eine zusätzliche Reise zum Server. • Momentan können Sie eine vorbereitete Anweisung nicht innerhalb einer gespeicherten Funktion anwenden (allerdings können Sie vorbereitete Anweisungen in gespeicherten Prozeduren benutzen). • Es ist möglich, versehentlich eine vorbereitete Anweisung »entweichen« zu lassen, wenn Sie vergessen, sie freizugeben. Das kann auf dem Server eine Menge Ressour-
Vorbereitete Anweisungen | 247
cen belegen. Und da es eine einzige globale Grenze für die Anzahl der vorbereiteten Anweisungen gibt, könnte ein solcher Fehler dazu führen, dass andere Verbindungen bei ihrem Einsatz von vorbereiteten Anweisungen gestört werden.
Benutzerdefinierte Funktionen MySQL unterstützt bereits lange benutzerdefinierte Funktionen (User-Defined Functions; UDFs). Im Gegensatz zu gespeicherten Funktionen, die in SQL geschrieben sind, können Sie UDFs in allen Programmiersprachen schreiben, die C-Aufrufkonventionen unterstützen. UDFs müssen kompiliert und dynamisch mit dem Server verknüpft werden, wodurch sie plattformspezifisch werden und Ihnen viel Macht verleihen. UDFs können sehr schnell sein und auf einen Großteil der Funktionalität des Betriebssystems und der verfügbaren Bibliotheken zugreifen. Gespeicherte SQL-Funktionen eignen sich gut für einfache Operationen wie das Berechnen der Orthodrome6 zwischen zwei Punkten auf dem Globus. Falls Sie dagegen Netzwerkpakete verschicken wollen, benötigen Sie eine benutzerdefinierte Funktion. Auch Aggregatfunktionen, die Sie momentan in SQL nicht herstellen können, sind mit einer UDF möglich. Große Macht bringt aber auch große Verantwortung mit sich. Ein Fehler in Ihrer UDF kann Ihren gesamten Server zum Absturz bringen, den Speicher des Servers und/oder Ihre Daten beschädigen und ganz allgemein den gleichen Schaden anrichten wie potenziell jeder wildgewordene C-Code. Im Gegensatz zu gespeicherten Funktionen, die in SQL geschrieben sind, können UDFs momentan keine Tabellen lesen und schreiben – zumindest nicht im gleichen transaktionellen Kontext wie die Anweisung, die sie aufgerufen hat. Das bedeutet, dass sie eher für reine Berechnungen oder die Interaktion mit der Außenwelt von Nutzen sind. MySQL erhält immer mehr Möglichkeiten für die Interaktion mit Ressourcen außerhalb des Servers. Die Funktionen, die Brian Aker und Patrick Galbraith erzeugt haben, um mit memcached (http://tangent.org/586/Memcached_Functions_for_ MySQL.html) zu kommunizieren, sind ein gutes Beispiel dafür, wie das mit UDFs erreicht werden kann.
Falls Sie UDFs benutzen, überprüfen Sie sorgfältig die Änderungen zwischen den MySQL-Versionen, wenn Sie aufrüsten, da sie möglicherweise neu kompiliert oder sogar geändert werden müssen, um korrekt mit dem neuen MySQL-Server zu funktionieren. Sorgen Sie außerdem dafür, dass Ihre UDFs absolut Thread-sicher sind, da sie innerhalb des MySQL-Serverprozesses, einer reinen Multithread-Umgebung, ausgeführt werden.
6 Eine Orthodrome ist die kürzeste Verbindung zwischen zwei Punkten auf einer Kugeloberfläche (siehe http://de.wikipedia.org/wiki/Orthodrome).
248 | Kapitel 5: Erweiterte MySQL-Funktionen
Es gibt gute Bibliotheken mit vorgefertigten UDFs für MySQL sowie viele gute Beispiele dafür, wie man eigene implementiert. Die größte Sammlung von UDFs finden Sie unter http://www.mysqludf.org. Hier folgt der Code für die UDF NOW_USEC( ), mit der wir die Replikationsgeschwindigkeit messen (siehe »Wie schnell ist die Replikation?« auf Seite 441): #include <my_global.h> #include <my_sys.h> #include <mysql.h> #include #include #include #include
<stdio.h> <sys/time.h>
extern "C" { my_bool now_usec_init(UDF_INIT *initid, UDF_ARGS *args, char *message); char *now_usec( UDF_INIT *initid, UDF_ARGS *args, char *result, unsigned long *length, char *is_null, char *error); } my_bool now_usec_init(UDF_INIT *initid, UDF_ARGS *args, char *message) { return 0; } char *now_usec(UDF_INIT *initid, UDF_ARGS *args, char *result, unsigned long *length, char *is_null, char *error) { struct timeval tv; struct tm* ptm; char time_string[20]; /* e.g. "2006-04-27 17:10:52" */ char *usec_time_string = result; time_t t; /* Tageszeit abfragen und in eine tm-Struktur konvertieren. */ gettimeofday (&tv, NULL); t = (time_t)tv.tv_sec; ptm = localtime (&t); /* Datum und Zeit bis auf die Sekunde runterformatieren. */ strftime (time_string, sizeof (time_string), "%Y-%m-%d %H:%M:%S", ptm); /* Formatierte Zeit in Sekunden mit Dezimalpunkt und Mikrosekunden ausgeben. */ sprintf(usec_time_string, "%s.%06ld\n", time_string, tv.tv_usec); *length = 26; return(usec_time_string); }
Benutzerdefinierte Funktionen | 249
Sichten Sichten sind eine beliebte Datenbankfunktion, die in MySQL 5.0 hinzugefügt wurde. Eine Sicht (View) in MySQL ist eine Tabelle, die selbst keine Daten speichert. Stattdessen werden die Daten »in« der Tabelle aus einer SQL-Abfrage abgeleitet. In diesem Buch wird nicht erläutert, wie man Sichten erzeugt oder anwendet; lesen Sie dazu den entsprechenden Abschnitt im MySQL-Handbuch, bzw. suchen Sie Beschreibungen für die Benutzung von Sichten in anderen Dokumentationen. MySQL behandelt eine Sicht für viele Zwecke genau wie eine Tabelle, außerdem teilen sich Sichten und Tabellen in MySQL den gleichen Namensraum; dennoch behandelt MySQL sie nicht identisch. So kann man z.B. keine Trigger in Sichten haben und kann eine Sicht auch nicht mit dem Befehl DROP TABLE verwerfen. Es ist wichtig, die interne Implementierung von Sichten und ihre Interaktion mit dem Abfrageoptimierer zu verstehen, da man sonst möglicherweise keine gute Performance mit ihnen erreicht. Wir demonstrieren anhand der Beispieldatenbank world, wie Sichten funktionieren: mysql> CREATE VIEW Oceania AS -> SELECT * FROM Country WHERE Continent = 'Oceania' -> WITH CHECK OPTION;
Am einfachsten implementiert der Server eine Sicht, indem er seine SELECT-Anweisung ausführt und das Ergebnis in eine temporäre Tabelle legt. Er kann sich dann auf die temporäre Tabelle beziehen, wenn der Name der Sicht in der Abfrage auftaucht. Damit Sie sehen, wie das funktionieren würde, schauen Sie sich folgende Abfrage an: mysql> SELECT Code, Name FROM Oceania WHERE Name = 'Australia';
Und so könnte der Server sie ausführen – der Name der temporären Tabelle steht hier nur zur Demonstration: mysql> CREATE TEMPORARY TABLE TMP_Oceania_123 AS -> SELECT * FROM Country WHERE Continent = 'Oceania'; mysql> SELECT Code, Name FROM TMP_Oceania_123 WHERE Name = 'Australia';
Es gibt bei diesem Ansatz offensichtlich Probleme mit der Performance und der Abfrageoptimierung. Eine bessere Methode, um Sichten zu implementieren, besteht darin, eine Abfrage umzuschreiben, die sich auf die Sicht bezieht, wobei das SQL der Sicht mit dem SQL der Abfrage zusammengefasst wird. Das folgende Beispiel zeigt, wie die Abfrage aussehen könnte, nachdem MySQL sie mit der Definition der Sicht gemischt hat: mysql> SELECT Code, Name FROM Country -> WHERE Continent = 'Oceania' AND Name = 'Australia';
MySQL kann beide Methoden anwenden. Es ruft die beiden Algorithmen MERGE und TEMPTABLE auf und versucht nach Möglichkeit, den MERGE-Algorithmus anzuwenden. MySQL kann sogar geschachtelte Sichtdefinitionen zusammenfassen, wenn eine Sicht auf einer anderen Sicht aufbaut. Sie sehen die Ergebnisse der neuen Abfrage mit EXPLAIN EXTENDED, gefolgt von SHOW WARNINGS.
250 | Kapitel 5: Erweiterte MySQL-Funktionen
Wenn eine Sicht den TEMPTABLE-Algorithmus benutzt, zeigt EXPLAIN sie normalerweise als DERIVED-Tabelle. Abbildung 5-4 verdeutlicht die beiden Implementierungen. Merge-Algorithmus
Temptable-Algorithmus
Client
Benutzer stellt Abfrage an Sicht
Client
Benutzer stellt Abfrage an Sicht SQL
SQL
Server fängt Abfrage ab
Server fängt Abfrage ab
Sicht
Server fasst Sicht-SQL und Abfrage-SQL zusammen
Sicht
SQL
SQL
SQL
Server liefert Ergebnis an Client zurück
Server liefert Ergebnis an Client zurück Server schreibt Abfrage so um, dass sie sich auf die temporäre Tabelle bezieht
SQL
Server führt die Abfrage des Benutzers an der temporären Tabelle aus
Server führt SQL an zugrundeliegenden Tabellen aus
SQL
Server speichert die Ergebnisse in einer temporären Tabelle mit der gleichen Struktur wie die Sicht
Server
Server führt das Sicht-SQL an den zugrundeliegenden Tabellen aus
Data
Server
Abbildung 5-4: Zwei Implementierungen von Sichten
MySQL verwendet TEMPTABLE, wenn die Definition der Sicht GROUP BY, DISTINCT, Aggregatfunktionen, UNION, Unterabfragen oder irgendein anderes Konstrukt enthält, das keine Eins-zu-eins-Beziehung zwischen den Zeilen der zugrunde liegenden Basistabellen und den Zeilen bewahrt, die aus der Sicht zurückgeliefert werden. Diese Liste ist nicht vollständig und kann sich in Zukunft auch noch ändern. Falls Sie wissen wollen, ob eine Sicht MERGE oder TEMPTABLE verwendet, sollten Sie eine triviale SELECT-Abfrage mit EXPLAIN anhand der Sicht profilieren: mysql> EXPLAIN SELECT * FROM ; +----+-------------+ | id | select_type | +----+-------------+ | 1 | PRIMARY | | 2 | DERIVED | +----+-------------+
Das Vorhandensein des Select-Typs DERIVED zeigt an, dass die Sicht den TEMPTABLE-Algorithmus benutzt.
Sichten | 251
Update-fähige Sichten Eine update-fähige Sicht erlaubt es Ihnen, die zugrunde liegenden Basistabellen über die Sicht zu aktualisieren. Solange bestimmte Bedingungen erfüllt sind, können Sie in einer Sicht wie in einer normalen Tabelle mit UPDATE, DELETE und sogar INSERT agieren. Dies ist z.B. eine gültige Operation: mysql> UPDATE Oceania SET Population = Population * 1.1 WHERE Name = 'Australia';
Eine Sicht ist nicht update-fähig, wenn sie GROUP BY, UNION, eine Aggregatfunktion oder einige andere Ausnahmen enthält. Eine Abfrage, die Daten ändert, könnte ein Join enthalten, allerdings müssen die Spalten, die geändert werden sollen, sich alle in einer einzigen Tabelle befinden. Sichten, die den TEMPTABLE-Algorithmus nutzen, sind nicht update-fähig. Die CHECK OPTION-Klausel, die wir der Sicht im vorangegangenen Abschnitt hinzugefügt haben, stellt sicher, dass Zeilen, die durch die Sicht geändert wurden, auch nach der Änderung der WHERE-Klausel der Sicht entsprechen. Wir können also weder die ContinentSpalte ändern noch eine Zeile einfügen, die einen anderen Continent besitzt. Beides würde den Server zu einer Fehlermeldung veranlassen: mysql> UPDATE Oceania SET Continent = 'Atlantis'; ERROR 1369 (HY000): CHECK OPTION failed 'world.Oceania'
Manche Datenbankprodukte erlauben INSTEAD OF-Trigger in Sichten, so dass man exakt definieren kann, was passiert, wenn eine Anweisung versucht, die Daten einer Sicht zu modifizieren. Allerdings gehört MySQL nicht dazu. Einige der Beschränkungen von MySQL in Bezug auf update-fähige Sichten verschwinden vielleicht in Zukunft, wodurch interessante und nützliche Anwendungen ermöglicht werden. Eine Möglichkeit wäre, Merge-Tabellen über Tabellen mit unterschiedlichen Storage-Engines herzustellen. Diese Art der Nutzung von Sichten wäre sehr leistungsfähig und sinnvoll.
Auswirkungen von Sichten auf die Leistung Die meisten Leute denken beim Einsatz von Sichten nicht an die Performance, allerdings kann ihre Benutzung tatsächlich die Leistung in MySQL verbessern. Man kann mit ihnen auch andere Leistungsverbesserungen unterstützen. Wenn Sie z.B. ein Schema so umbauen, dass in einigen Stadien Sichten verwendet werden, dann ermöglichen Sie es, dass ein Teil des Codes weiterarbeitet, während Sie die Tabelle ändern, auf die er zugreift. Manche Anwendungen benutzen eine Tabelle pro Benutzer – im Allgemeinen, um eine Form von Sicherheit auf Zeilenebene zu implementieren. Eine Sicht, die ähnlich derjenigen ist, die wir zuvor gezeigt haben, könnte eine vergleichbare Sicherheit innerhalb einer einzigen Tabelle bieten, und wenn weniger Tabellen offen sind, verbessert sich auch die Leistung. Viele Open-Source-Projekte, die in riesigen Hosting-Umgebungen eingesetzt werden, sammeln mit der Zeit Millionen von Tabellen an und könnten daher von diesem Ansatz profitieren. Hier ist ein Beispiel für einen hypothetischen Blog-Hosting-Datenbankserver:
252 | Kapitel 5: Erweiterte MySQL-Funktionen
CREATE VIEW blog_posts_for_user_1234 AS SELECT * FROM blog_posts WHERE user_id = 1234 WITH CHECK OPTION;
Mithilfe von Sichten können Sie Spaltenberechtigungen implementieren, ohne dass Sie tatsächlich den Aufwand auf sich nehmen müssen, diese Berechtigungen anzulegen, der ziemlich hoch sein kann. Spaltenberechtigungen verhindern außerdem, dass Abfragen an der Tabelle im Abfrage-Cache gespeichert werden. Eine Sicht kann den Zugriff auf die gewünschten Spalten beschränken, ohne dass diese Probleme verursacht: CREATE VIEW public.employeeinfo AS SELECT firstname, lastname -- but not socialsecuritynumber FROM private.employeeinfo; GRANT SELECT ON public.* TO public_user;
Manchmal bieten auch pseudotemporäre Sichten gute Ergebnisse. Es ist eigentlich nicht möglich, eine wirklich temporäre Sicht zu erzeugen, die nur für die Dauer Ihrer aktuellen Verbindung besteht. Allerdings können Sie eine Sicht unter einem speziellen Namen, vielleicht in einer extra dafür reservierten Datenbank, erzeugen, die Sie später guten Gewissens verwerfen. Anschließend benutzen Sie die Sicht in der FROM-Klausel fast genauso wie eine Unterabfrage in der FROM-Klausel. Die beiden Ansätze sind theoretisch gleich, allerdings hat MySQL für Sichten eine andere Codebasis, so dass Sie aus der temporären Sicht wahrscheinlich eine bessere Leistung ziehen. Hier ist ein Beispiel: -- Assuming 1234 is the result of CONNECTION_ID( ) CREATE VIEW temp.cost_per_day_1234 AS SELECT DATE(ts) AS day, sum(cost) AS cost FROM logs.cost GROUP BY day; SELECT c.day, c.cost, s.sales FROM temp.cost_per_day_1234 AS c INNER JOIN sales.sales_per_day AS s USING(day); DROP VIEW temp.cost_per_day_1234;
Beachten Sie, dass wir die Verbindungs-ID als eindeutiges Suffix verwendet haben, um Namenskonflikte zu vermeiden. Dieser Ansatz erleichtert das Aufräumen, falls die Anwendung abstürzt und die temporäre Sicht nicht wegwirft. In »Fehlende temporäre Tabellen« auf Seite 429 finden Sie weitere Informationen über diese Technik. Sichten, die den TEMPTABLE-Algorithmus benutzen, funktionieren unter Umständen schlecht (allerdings immer noch besser als eine äquivalente Abfrage ohne Sicht). MySQL führt sie als rekursiven Schritt beim Optimieren der äußeren Abfrage aus, bevor die äußere Abfrage vollständig optimiert wurde. Sie haben deshalb nicht so viel von den Optimierungen, wie Sie vielleicht von anderen Datenbankprodukten gewöhnt sind. Der Abfrage, die die temporäre Tabelle aufbaut, werden keine WHERE-Bedingungen von der äußeren Abfrage übergeben, und die temporäre Tabelle enthält keine Indizes. Hier ist ein Beispiel, wieder mit der Sicht temp.cost_per_day_1234:
Sichten | 253
mysql> SELECT c.day, c.cost, s.sales -> FROM temp.cost_per_day_1234 AS c -> INNER JOIN sales.sales_per_day AS s USING(day) -> WHERE day BETWEEN '2007-01-01' AND '2007-01-31';
Was passiert wirklich in dieser Abfrage? Der Server führt die Sicht aus und setzt das Ergebnis in eine temporäre Tabelle. Anschließend führt er die sales_per_day-Tabelle in einem Join mit dieser temporären Tabelle zusammen. Die BETWEEN-Beschränkung in der WHERE-Klausel wird nicht in die Sicht »hineingedrückt«, so dass die Sicht eine Ergebnismenge für alle Daten in der Tabelle und nicht nur für den gewünschten Monat erzeugt. Die temporäre Tabelle enthält darüber hinaus keine Indizes. In diesem Beispiel ist das kein Problem: Der Server setzt die temporäre Tabelle an die erste Stelle in der Join-Reihenfolge, so dass der Join den Index in der sales_per_day-Tabelle benutzen kann. Falls Sie allerdings zwei solcher Sichten mit einem Join zusammenführen, würde der Join nicht mit irgendwelchen Indizes optimiert werden. Sie sollten immer Benchmark-Tests oder wenigstens ein ausführliches Profiling durchführen, wenn Sie versuchen, die Performance mithilfe von Sichten zu verbessern. Selbst MERGE-Sichten verursachen Mehraufwand, und es lässt sich nur schwer vorhersagen, wie eine Sicht die Leistung beeinflusst. Wenn die Leistung wichtig ist, dann raten Sie nicht, sondern messen Sie, und zwar immer. Sichten verursachen einige Probleme, die nicht MySQL-spezifisch sind. Entwickler nehmen möglicherweise an, dass sie einfach sind, obwohl sie in Wirklichkeit ziemlich kompliziert sind. Ein Entwickler, der die zugrunde liegende Komplexität nicht verstanden hat, denkt sich vielleicht nichts dabei, wenn wiederholt etwas abgefragt wird, was wie eine Tabelle aussieht, aber tatsächlich eine teure Sicht ist. Uns sind Fälle begegnet, in denen eine augenscheinlich einfache Abfrage Hunderte von Zeilen EXPLAIN-Ausgabe verursacht hat, weil es sich bei einer oder mehreren der »Tabellen«, auf die sie sich bezog, eigentlich um eine Sicht gehandelt hat, die auf viele weitere Tabellen und Sichten verwies.
Beschränkungen von Sichten MySQL bietet keine Unterstützung für die materialisierten Sichten, an die Sie möglicherweise von anderen Datenbankservern her gewöhnt sind. (Eine materialisierte Sicht speichert ihre Ergebnisse im Allgemeinen in einer unsichtbaren Tabelle hinter den Kulissen; diese Tabelle wird regelmäßig aus den Quelldaten heraus aktualisiert.) MySQL unterstützt auch keine indizierten Sichten. Sie können materialisierte und/oder indizierte Sichten jedoch mithilfe von Cache- und Summary-Tabellen simulieren; in MySQL 5.1 lassen sich diese Aufgaben mit Events steuern. Die MySQL-Implementierung der Sichten birgt einige Ärgernisse. Das größte Ärgernis besteht darin, dass MySQL das SQL Ihrer Originalsicht nicht bewahrt. Falls Sie also jemals versuchen, eine Sicht zu bearbeiten, indem Sie SHOW CREATE VIEW ausführen, und das resultierende SQL ändern, wartet eine hässliche Überraschung auf Sie: Die Abfrage wird auf das komplett kanonisierte und quotierte interne Format erweitert, ohne Formatierung, Kommentare und Einrückungen.
254 | Kapitel 5: Erweiterte MySQL-Funktionen
Falls Sie eine Sicht bearbeiten müssen und die hübsch anzusehende Abfrage verloren haben, die Sie ursprünglich benutzt hatten, um die Sicht zu erzeugen, dann suchen Sie in der letzten Zeile der .frm-Datei der Sicht. Wenn Sie die FILE-Berechtigung haben und die .frm-Datei von allen Benutzern gelesen werden kann, können Sie den Inhalt der Datei sogar mit der LOAD_FILE( )-Funktion laden. Mit ein wenig Stringmanipulation bekommen Sie – wiederum dank der Kreativität von Roland Bouman – Ihren Originalcode heil wieder zurück: mysql> SELECT -> REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE( -> REPLACE(REPLACE(REPLACE(REPLACE(REPLACE( -> SUBSTRING_INDEX(LOAD_FILE('/var/lib/mysql/world/Oceania.frm'), -> '\nsource=', -1), -> '\\_','\_'), '\\%','\%'), '\\\\','\\'), '\\Z','\Z'), '\\t','\t'), -> '\\r','\r'), '\\n','\n'), '\\b','\b'), '\\\"','\"'), '\\\'','\''), -> '\\0','\0') -> AS source; +-------------------------------------------------------------------------+ | source | +-------------------------------------------------------------------------+ | SELECT * FROM Country WHERE continent = 'Oceania' | | WITH CHECK OPTION | | | +-------------------------------------------------------------------------+
Zeichensätze und Sortierreihenfolgen Ein Zeichensatz ist eine Zuordnung von Binärkodierungen auf eine definierte Menge von Symbolen; stellen Sie es sich als Darstellung eines bestimmten Alphabets in Form von Bits vor. Die Sortierreihenfolge (auch Kollation) bezeichnet eine Reihe von Sortierregeln für einen Zeichensatz. Seit MySQL 4.1 kann jeder zeichenbasierte Wert einen Zeichensatz und eine Sortierreihenfolge besitzen.7 Die MySQL-Unterstützung für Zeichensätze und Kollationen ist erstklassig, kann aber die Komplexität erhöhen und in manchen Fällen auf Kosten der Leistung gehen. In diesem Abschnitt werden die Einstellungen und Funktionen erklärt, die Sie für die meisten Situationen benötigen. Falls Sie die esoterischeren Einzelheiten interessieren, dann lesen Sie das MySQL-Handbuch.
Wie MySQL Zeichensätze benutzt Zeichensätze können mehrere Sortierreihenfolgen aufweisen; außerdem besitzt jeder Zeichensatz eine vorgegebene Sortierreihenfolge. Sortierreihenfolgen wiederum gehören zu einem bestimmten Zeichensatz und können nicht zusammen mit einem anderen verwen-
7 Bis MySQL 4.0 gab es eine globale Einstellung für den gesamten Server, und man konnte zwischen mehreren 8-Bit-Zeichensätzen wählen.
Zeichensätze und Sortierreihenfolgen | 255
det werden. Sie benutzen einen Zeichensatz und eine Sortierreihenfolge immer zusammen, weshalb wir beide von nun an zusammenfassend als Zeichensatz bezeichnen. MySQL besitzt eine Vielzahl von Optionen, mit denen Zeichensätze kontrolliert werden. Die Optionen und die Zeichensätze werden leicht verwechselt, behalten Sie deshalb diese Unterscheidung im Hinterkopf: Nur zeichenbasierte Werte können wirklich einen Zeichensatz »haben«. Alles andere ist nur eine Einstellung, die angibt, welcher Zeichensatz für Vergleiche und andere Operationen verwendet werden soll. Ein zeichenbasierter Wert kann der Wert sein, der in einer Spalte gespeichert ist, ein Literal in einer Abfrage, das Ergebnis eines Ausdrucks, eine Benutzervariable usw. Die MySQL-Einstellungen lassen sich in zwei Klassen unterteilen: Vorgaben zum Erzeugen von Objekten und Einstellungen, die die Kommunikation zwischen Server und Client steuern.
Vorgabewerte zum Erzeugen von Objekten MySQL hat für den Server, für jede Datenbank und für jede Tabelle einen vorgegebenen Zeichensatz und eine Sortierreihenfolge. Diese formen eine Hierarchie aus Vorgabewerten, die den Zeichensatz beeinflussen, der verwendet wird, wenn Sie eine Spalte erzeugen. Das wiederum teilt dem Server mit, welcher Zeichensatz für die Werte benutzt werden soll, die Sie in der Spalte speichern. Sie können in jeder Stufe der Hierarchie explizit einen Zeichensatz angeben. Es ist aber auch möglich, dem Server die Wahl der passenden Vorgabe zu überlassen: • Wenn Sie eine Datenbank erzeugen, übernimmt er die serverweite character_set_ server-Einstellung. • Wenn Sie eine Tabelle erzeugen, übernimmt er sie aus der Datenbank. • Wenn Sie eine Spalte erzeugen, übernimmt er sie aus der Tabelle. Denken Sie daran, dass Spalten die einzige Stelle sind, in der MySQL Werte speichert, so dass die höheren Ebenen in der Hierarchie nur Vorgabewerte darstellen. Der vorgegebene Zeichensatz einer Tabelle beeinflusst die Werte nicht, die in den Tabellen gespeichert sind, sondern teilt MySQL nur mit, welchen Zeichensatz es benutzen soll, wenn Sie eine Spalte erzeugen, ohne explizit einen Zeichensatz anzugeben.
Einstellungen für die Client/Server-Kommunikation Wenn Server und Client miteinander kommunizieren, senden sie möglicherweise Daten in unterschiedlichen Zeichensätzen hin und her. Der Server übersetzt sie entsprechend: • Der Server nimmt an, dass der Client Anweisungen in dem Zeichensatz sendet, der durch character_set_client angegeben ist. • Nachdem der Server eine Anweisung vom Client empfangen hat, übersetzt er sie in den Zeichensatz, der durch character_set_connection angegeben ist. Diese Einstellung benutzt er außerdem, um festzustellen, wie Zahlen in Strings übersetzt werden sollen.
256 | Kapitel 5: Erweiterte MySQL-Funktionen
• Wenn der Server Ergebnisse oder Fehlermeldungen an den Client zurückliefert, übersetzt er sie in character_set_result. Abbildung 5-5 verdeutlicht diesen Vorgang. Server Konvertiert character_set_client in character_set_connection
Anweisung Verarbeitet Abfrage Ergebnis Client Konvertiert character_set_connection in character_set_client
Abbildung 5-5: Client- und Serverzeichensätze
Sie können diese Einstellungen bei Bedarf mit den Anweisungen SET NAMES bzw. SET CHARACTER SET ändern. Beachten Sie allerdings, dass dieser Befehl nur die Einstellungen des Servers beeinflusst. Das Clientprogramm und die Client-API müssen ebenfalls korrekt eingestellt sein, um Kommunikationsprobleme mit dem Server zu vermeiden. Nehmen Sie einmal an, dass Sie eine Clientverbindung mit Latin1 (dem vorgegebenen Zeichensatz, falls Sie ihn nicht mit mysql_options( ) geändert haben) öffnen und dann dem Server mit SET NAMES utf8 mitteilen, dass er annehmen soll, dass der Client seine Daten in UTF-8 sendet. Sie haben eine Fehlanpassung der Zeichensätze geschaffen, die Fehler und sogar Sicherheitsprobleme verursachen kann. Sie sollten den Zeichensatz des Clients einstellen und mysql_real_escape_string( ) benutzen, wenn Sie Werte schützen. In PHP ändern Sie den Zeichensatz des Clients mit mysql_set_charset( ).
Wie MySQL Werte vergleicht Wenn MySQL zwei Werte mit unterschiedlichen Zeichensätzen vergleicht, muss es sie für den Vergleich in denselben Zeichensatz konvertieren. Wenn die Zeichensätze nicht kompatibel sind, kann ein Fehler auftreten, wie etwa »ERROR 1267 (HY000): Illegal mix of collations«. In diesem Fall müssen Sie im Allgemeinen explizit die Funktion CONVERT( ) benutzen, um einen der Werte in einen Zeichensatz zu zwingen, der kompatibel zu dem anderen ist. Seit MySQL 5.0 wird diese Konvertierung oft implizit vorgenommen, so dass dieser Fehler eher aus MySQL 4.1 bekannt ist. MySQL weist den Werten außerdem eine sogenannte Anpassbarkeit (Coercibility) zu. Diese ermittelt die Priorität des Zeichensatzes eines Wertes und beeinflusst, welchen
Zeichensätze und Sortierreihenfolgen | 257
Wert MySQL implizit konvertiert. Ihnen stehen die Funktionen CHARSET( ), COLLATION( ) und COERCIBILITY( ) zur Verfügung, um Fehler im Zusammenhang mit Zeichensätzen und Sortierreihenfolgen zu beheben. Sie können Introducer und Collate-Klauseln benutzen, um den Zeichensatz und/oder die Sortierreihenfolge für literale Werte in Ihren SQL-Anweisungen anzugeben. Zum Beispiel: mysql> SELECT _utf8 'hello world' COLLATE utf8_bin; +--------------------------------------+ | _utf8 'hello world' COLLATE utf8_bin | +--------------------------------------+ | hello world | +--------------------------------------+
Besondere Verhaltensweisen Die Verhaltensweisen der MySQL-Zeichensätze halten einige Überraschungen bereit. Auf folgende Dinge sollten Sie achten: Die magische character_set_database-Einstellung Die Einstellung character_set_database entspricht standardmäßig dem vorgegebenen Wert der Datenbank. Wenn Sie Ihre Standarddatenbank ändern, ändert sich auch dieser Wert. Falls Sie die Verbindung zum Server ohne vorgegebene Datenbank vornehmen, wird standardmäßig character_set_server eingestellt. LOAD DATA INFILE LOAD DATA INFILE interpretiert eingehende Daten entsprechend der aktuellen Einstellung von character_set_database. Manche Versionen von MySQL akzeptieren eine optionale CHARACTER SET-Klausel in der Anweisung LOAD DATA INFILE, darauf sollten
Sie sich aber nicht verlassen. Wir haben festgestellt, dass die beste Methode, um zuverlässige Ergebnisse zu bekommen, darin besteht, mit USE die gewünschte Datenbank anzugeben, SET NAMES auszuführen, um einen Zeichensatz zu wählen, und dann nur die Daten zu laden. MySQL interpretiert alle geladenen Daten mit dem gleichen Zeichensatz, ungeachtet der Zeichensätze, die tatsächlich für die Zielspalten festgelegt wurden. SELECT INTO OUTFILE
MySQL schreibt alle Daten aus SELECT INTO OUTFILE, ohne sie zu konvertieren. Es gibt momentan keine Möglichkeit, einen Zeichensatz für die Daten einzustellen, ohne jede Spalte in eine CONVERT( )-Funktion einzupacken. Eingebettete Escape-Folgen MySQL interpretiert Escape-Folgen in Anweisungen entsprechend character_ set_client, selbst wenn es einen Introducer oder eine Collate-Klausel gibt. Das liegt daran, dass der Parser die Escape-Folgen in literalen Werten interpretiert. Der Parser achtet nicht auf die Sortierreihenfolge – sofern es ihn betrifft, ist ein Introducer kein Befehl, sondern nur ein Token.
258 | Kapitel 5: Erweiterte MySQL-Funktionen
Einen Zeichensatz und eine Sortierreihenfolge wählen Ab Version 4.1 unterstützt MySQL eine große Anzahl von Zeichensätzen und Sortierreihenfolgen. Dazu gehören auch Multibyte-Zeichen mit der UTF-8-Kodierung des UnicodeZeichensatzes (MySQL unterstützt eine drei Byte große Teilmenge des vollständigen UTF 8, das die meisten Zeichen aus den meisten Sprachen speichern kann). Sie können sich die unterstützten Zeichensätze mit den Befehlen SHOW CHARACTER SET und SHOW COLLATION anzeigen lassen.
Machen Sie es sich einfach Ein Mix aus Zeichensätzen in Ihrer Datenbank kann eine echte Plage sein. Inkompatible Zeichensätze sind in der Regel schrecklich verwirrend. Sie können gut funktionieren, bis bestimmte Zeichen in Ihren Daten auftauchen. Ab diesem Moment kommt es in allen möglichen Operationen zu Problemen (etwa in Joins zwischen Tabellen). Sie können diese Probleme nur lösen, indem Sie ALTER TABLE einsetzen, um die Spalten in kompatible Zeichensätze umzuwandeln oder indem Sie Werte mit Introducern und Collate-Klauseln in den SQL-Anweisungen in den gewünschten Zeichensatz bringen. Vernünftigerweise ist es am besten, wenn man auf der Serverebene und möglicherweise auf der Datenbankebene sinnvolle Standardwerte wählt. Dann kann man nämlich besondere Ausnahmen fallweise behandeln, z.B. auf Spaltenebene.
Die gebräuchlichsten Entscheidungen für Sortierreihenfolgen (Kollationen) sind, ob die Buchstaben unter Beachtung der Groß- und Kleinschreibung sortiert werden sollen oder entsprechend dem Binärwert der Kodierung. Die Namen der Kollationen enden im Allgemeinen mit _cs (case sensitive, d.h. unter Beachtung von Groß-/Kleinschreibung), _ci (case insensitive, d.h. nicht unter Beachtung von Groß-/Kleinschreibung) oder _bin, so dass Sie sie leicht auseinanderhalten können. Wenn Sie einen Zeichensatz explizit festlegen, müssen Sie nicht sowohl den Zeichensatz als auch die Sortierreihenfolge angeben. Falls Sie eine oder beide Angaben weglassen, setzt MySQL die fehlenden Werte aus der passenden Vorgabe ein. Tabelle 5-2 zeigt, wie MySQL über Zeichensatz und Sortierreihenfolge entscheidet. Tabelle 5-2: Wie MySQL Vorgaben für Zeichensätze und Sortierreihenfolgen ermittelt Sie legen fest
Resultierender Zeichensatz
Resultierende Sortierreihenfolge
Sowohl den Zeichensatz als auch die Sortierreihenfolge
Wie angegeben
Wie angegeben
Nur den Zeichensatz
Wie angegeben
Vorgegebene Sortierreihenfolge des Zeichensatzes
Nur die Sortierreihenfolge
Zeichensatz, zu der die Sortierreihenfolge gehört
Wie angegeben
Nichts
Passende Vorgabe
Passende Vorgabe
Zeichensätze und Sortierreihenfolgen | 259
Die folgenden Befehle zeigen, wie man eine Datenbank, eine Tabelle und eine Spalte mit explizit angegebenen Zeichensätzen und Sortierreihenfolgen erzeugt: CREATE DATABASE d CHARSET latin1; CREATE TABLE d.t( col1 CHAR(1), col2 CHAR(1) CHARSET utf8, col3 CHAR(1) COLLATE latin1_bin ) DEFAULT CHARSET=cp1251;
Die Spalten der resultierenden Tabelle weisen folgende Sortierreihenfolgen auf: mysql> SHOW FULL COLUMNS FROM d.t; +-------+---------+-------------------+ | Field | Type | Collation | +-------+---------+-------------------+ | col1 | char(1) | cp1251_general_ci | | col2 | char(1) | utf8_general_ci | | col3 | char(1) | latin1_bin | +-------+---------+-------------------+
Wie Zeichensätze und Sortierreihenfolgen Abfragen beeinflussen Manche Zeichensätze erfordern möglicherweise mehr CPU-Operationen, verbrauchen mehr Speicher und Festplattenplatz oder verhindern sogar eine Indizierung. Das sollten Sie bei der Wahl der Zeichensätze und Sortierreihenfolgen beachten. Das Konvertieren zwischen Zeichensätzen oder Sortierreihenfolgen kann den Overhead für bestimmte Operationen vergrößern. So besitzt z.B. die sakila.film-Tabelle einen Index in der title-Spalte, der ORDER BY-Abfragen beschleunigen kann: mysql> EXPLAIN SELECT title, release_year FROM sakila.film ORDER BY title\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: film type: index possible_keys: NULL key: idx_title key_len: 767 ref: NULL rows: 953 Extra:
Allerdings kann der Server den Index nur dann für die Sortierung benutzen, wenn er mit der gleichen Sortierreihenfolge sortiert ist, wie in der Abfrage angegeben. Der Index wird mit der Sortierreihenfolge der Spalte sortiert, in diesem Fall also utf8_general_ci. Sollen die Ergebnisse nach einer anderen Sortierreihenfolge sortiert werden, muss der Server ein Filesort durchführen: mysql> EXPLAIN SELECT title, release_year -> FROM sakila.film ORDER BY title COLLATE utf8_bin\G *************************** 1. row ***************************
260 | Kapitel 5: Erweiterte MySQL-Funktionen
id: select_type: table: type: possible_keys: key: key_len: ref: rows: Extra:
1 SIMPLE film ALL NULL NULL NULL NULL 953 Using filesort
MySQL muss nicht nur die Vorgaben bezüglich des Zeichensatzes der Verbindung und anderer Angaben beachten, die Sie explizit in Ihren Abfragen getroffen haben, sondern muss auch Zeichensätze konvertieren, damit es sie vergleichen kann, falls sie nicht gleich sind. Falls Sie z.B. zwei Tabellen aus Zeichenspalten mit ungleichen Zeichensätzen mit einem Join verbinden, muss MySQL einen der beiden Zeichensätze konvertieren. Diese Umwandlung kann den Einsatz eines Index verhindern, da sie sich genau wie eine Funktion verhält, die die Spalte einschließt. Der UTF-8-Multibyte-Zeichensatz speichert die einzelnen Zeichen mit einer unterschiedlichen Anzahl von Bytes (zwischen einem und drei). MySQL verwendet intern für viele Stringoperationen Puffer fester Größe, muss also genug Platz für die maximal mögliche Länge reservieren. So erfordert z.B. ein CHAR(10), das mit UTF-8 kodiert ist, 30 Bytes für die Speicherung, selbst wenn der eigentliche String keine sogenannten Wide-CharacterZeichen enthält. Für Felder variabler Länge (VARCHAR, TEXT) macht das auf der Festplatte nichts aus, temporäre Tabellen im Speicher, die zum Verarbeiten und Sortieren von Abfragen benutzt werden, reservieren dagegen immer die maximal benötigte Länge. In Multibyte-Zeichensätzen ist ein Zeichen nicht mehr das Gleiche wie ein Byte. Infolgedessen besitzt MySQL separate LENGTH( )- und CHAR_LENGTH( )-Funktionen, die für Multibyte-Zeichen nicht die gleichen Ergebnisse zurückliefern. Wenn Sie mit MultibyteZeichensätzen arbeiten, sollten Sie darauf achten, dass Sie die Funktion CHAR_LENGTH( ) benutzen, wenn Sie Zeichen zählen wollen (z.B. wenn Sie SUBSTRING( )-Operationen durchführen). Der gleiche Hinweis gilt für Multibyte-Zeichen in Anwendungssprachen. Eine weitere mögliche Überraschung sind Indexbeschränkungen. Wenn Sie eine UTF-8Spalte indizieren, muss MySQL davon ausgehen, dass jedes Zeichen bis zu drei Bytes annehmen kann, so dass die üblichen Längenbeschränkungen plötzlich um den Faktor drei schrumpfen: mysql> CREATE TABLE big_string(str VARCHAR(500), KEY(str)) DEFAULT CHARSET=utf8; Query OK, 0 rows affected, 1 warning (0.06 sec) mysql> SHOW WARNINGS; +---------+------+---------------------------------------------------------+ | Level | Code | Message | +---------+------+---------------------------------------------------------+ | Warning | 1071 | Specified key was too long; max key length is 999 bytes | +---------+------+---------------------------------------------------------+
Zeichensätze und Sortierreihenfolgen | 261
Beachten Sie, dass MySQL den Index automatisch auf ein 333-Zeichen-Präfix gekürzt hat: mysql> SHOW CREATE TABLE big_string\G *************************** 1. row *************************** Table: big_string Create Table: CREATE TABLE `big_string` ( `str` varchar(500) default NULL, KEY `str` (`str`(333)) ) ENGINE=MyISAM DEFAULT CHARSET=utf8
Falls Sie die Warnung nicht bemerkt und die Tabellendefinition überprüft haben, ist Ihnen möglicherweise entgangen, dass der Index nur auf einem Präfix der Spalte angelegt wurde. Das hat Nebenwirkungen wie etwa das Deaktivieren abdeckender Indizes. Manche Leute empfehlen, einfach global UTF-8 zu verwenden, um »sich das Leben zu erleichtern«. Das ist jedoch eine eher schlechte Idee, wenn Sie eine gute Performance erwarten. Viele Anwendungen benötigen überhaupt kein UTF-8, und je nach Ihren Daten kann UTF-8 auf der Festplatte sehr viel Speicherplatz in Anspruch nehmen. Wenn Sie sich für einen Zeichensatz entscheiden, müssen Sie die Art der Daten in Betracht ziehen, die Sie speichern werden. Falls Sie etwa hauptsächlich englische Texte speichern, gibt es bei der Speicherung praktisch keinen Aufschlag aufgrund der Verwendung von UTF-8, da die meisten Zeichen in der englischen Sprache in UTF-8 in ein Byte passen. Andererseits macht es einen großen Unterschied, wenn Sie Sprachen speichern, die keine lateinischen Buchstaben verwenden, wie etwa Russisch oder Arabisch. Eine Anwendung, die nur Arabisch speichern muss, könnte den cp1256-Zeichensatz benutzen, der alle arabischen Zeichen in jeweils einem Byte darstellen kann. Muss die Anwendung dagegen viele verschiedene Sprachen speichern, und Sie wählen stattdessen UTF-8, benötigen die gleichen arabischen Zeichen viel mehr Platz. Falls Sie eine Spalte aus einem nationalen Zeichensatz nach UTF-8 konvertieren, kann sich der erforderliche Speicherplatz deutlich erhöhen. Bei InnoDB könnte sich die Datengröße derart erhöhen, dass die Werte nicht auf die Seite passen und externen Speicher benötigen, was wiederum zu einer Menge verschwendetem Speicher und zu Fragmentierung führt. Mehr Informationen zu diesem Thema finden Sie in »Für BLOB- und TEXT-Lasten optimieren« auf Seite 323. Manchmal müssen Sie überhaupt keinen Zeichensatz einsetzen. Zeichensätze sind für Vergleiche ohne Beachtung der Groß-/Kleinschreibung, Sortierung und Stringoperationen, die Zeichen erkennen müssen, wie etwa SUBSTRING( ), am nützlichsten. Falls der Datenbankserver die Zeichen nicht erkennen muss, speichern Sie alles einfach in BINARYSpalten, auch die UTF-8-Daten. Sie könnten in diesem Fall eine Spalte hinzufügen, die Ihnen mitteilt, welchen Zeichensatz Sie für die Kodierung der Daten benutzt haben. Dieser Ansatz wird von manchen Leuten zwar schon sehr lange verfolgt, allerdings muss man dabei auch mehr aufpassen. Er kann Fehler verursachen, die schwer zu erkennen sind, wie etwa Fehler mit SUBSTRING( ) und LENGTH( ), wenn Sie vergessen, dass ein Byte nicht unbedingt ein Zeichen ist. Wir empfehlen Ihnen, diese Technik nach Möglichkeit nicht zu verwenden. 262 | Kapitel 5: Erweiterte MySQL-Funktionen
Volltextsuche Die meisten der Abfragen, die Sie schreiben, enthalten wahrscheinlich WHERE-Klauseln, die Werte auf Gleichheit untersuchen, Zeilenbereiche herausfiltern usw. Allerdings kann es auch vorkommen, dass Sie eine Stichwortsuche durchführen müssen, die auf Relevanz und nicht auf dem Vergleich von Werten beruht. Für diesen Zweck gibt es Volltextsuchsysteme. Volltextsuchen erfordern eine besondere Abfragesyntax. Sie können mit oder ohne Indizes arbeiten – Indizes beschleunigen allerdings die Vergleiche. Indizes, die für Volltextsuchen benutzt werden, weisen eine besondere Struktur auf, um das Auffinden der Dokumente zu unterstützen, die die gewünschten Schlüsselwörter enthalten. Sie sind sich dessen vielleicht nicht bewusst, doch Sie sind bereits mit wenigstens einer Art von Volltextsuchsystem vertraut: Internet-Suchmaschinen. Diese arbeiten zwar in einem viel größeren Maßstab und haben normalerweise keine relationale Datenbank im Hintergrund, die Prinzipien sind allerdings ähnlich. In MySQL unterstützt nur die MyISAM-Storage-Engine die Volltextindizierung. Sie erlaubt es Ihnen, zeichenbasierten Inhalt zu suchen (CHAR-, VARCHAR- und TEXT-Spalten), und unterstützt sowohl natürlichsprachige als auch Boolesche Suchen. Die Implementierung der Volltextsuche unterliegt einigen Einschränkungen und Grenzen8 und ist recht kompliziert, ist aber dennoch weit verbreitet, da sie im Server enthalten ist und sich für viele Anwendungen eignet. In diesem Abschnitt schauen wir uns ganz allgemein an, wie man sie benutzt und wie man die Volltextsuche so gestaltet, dass man eine adäquate Leistung erreicht. Ein MyISAM-Volltextindex arbeitet auf einer Volltextsammlung, die aus einer oder mehreren Zeichenspalten aus einer einzigen Tabelle erzeugt wird. Im Prinzip baut MySQL den Index auf, indem es die Spalten in der Sammlung aneinanderhängt und sie dann als einen langen Textstring indiziert. Bei einem MyISAM-Volltextindex handelt es sich um eine besondere Art von B-BaumIndex mit zwei Ebenen. Die erste Ebene enthält die Schlüsselwörter. Die zweite Ebene enthält dann für jedes Schlüsselwort eine Liste mit passend zugewiesenen Dokumentzeigern, die auf Volltextsammlungen verweisen, in denen dieses Schlüsselwort vorhanden ist. Der Index enthält nicht jedes Wort aus der Sammlung. Er wird folgendermaßen gekürzt: • Eine Liste mit Stoppwörtern siebt Füllwörter aus, indem sie verhindert, dass diese indiziert werden. Die Stoppwortliste basiert standardmäßig auf gebräuchlichem englischsprachigem Einsatz, Sie können sie jedoch mithilfe der Option ft_stopword_ file durch eine Liste aus einer externen Datei ersetzen. 8 Sie stellen vielleicht fest, dass die Beschränkungen der Volltextfunktionen von MySQL den Einsatz für Ihre Anwendung unpraktisch oder unmöglich erscheinen lassen. Wir besprechen die Verwendung von Sphinx als externe Volltextsuchmaschine in Anhang C.
Volltextsuche | 263
• Der Index ignoriert Wörter, die weniger als ft_min_word_len Zeichen und mehr als ft_max_word_len Zeichen aufweisen. Volltextindizes speichern keine Informationen darüber, in welcher Spalte in der Sammlung ein Schlüsselwort auftaucht. Falls Sie also in unterschiedlichen Kombinationen aus Spalten suchen wollen, müssen Sie mehrere Indizes erzeugen. Das bedeutet außerdem, dass Sie eine MATCH AGAINST-Klausel nicht anweisen können, Wörter aus einer bestimmten Spalte als wichtiger zu betrachten als Wörter aus anderen Spalten. Wenn Sie Suchmaschinen für Websites bauen, ist das jedoch eine häufig gestellte Anforderung. So wollen Sie ja möglicherweise, dass Suchergebnisse an vorderen Stellen auftauchen, wenn die Stichwörter im Titel eines Eintrags stehen. In diesem Fall müssen Sie kompliziertere Abfragen schreiben. (Wir zeigen später ein Beispiel.)
Natürlichsprachige Volltextsuchen Eine natürlichsprachige Suchabfrage ermittelt die Relevanz jedes Dokuments für die Abfrage. Die Relevanz basiert auf der Anzahl der passenden Wörter und der Häufigkeit, mit der sie in dem Dokument auftauchen. Wörter, die in dem gesamten Index weniger gebräuchlich sind, erhöhen die Relevanz eines Treffers. Im Gegensatz dazu lohnt sich die Suche nach ausgesprochen häufig auftretenden Wörtern überhaupt nicht. Eine natürlichsprachige Volltextsuche schließt Wörter aus, die in mehr als 50 % der Zeilen in der Tabelle vorkommen, auch wenn sie nicht in der Liste der Stoppwörter stehen.9 Die Syntax einer Volltextsuche unterscheidet sich ein wenig von anderen Abfragearten. Sie weisen MySQL mit MATCH AGAINST in der WHERE-Klausel an, einen Volltextvergleich durchzuführen. Wir wollen uns ein Beispiel anschauen. In der normalen Sakila-Beispieldatenbank hat die film_text-Tabelle einen Volltextindex in den Spalten title und description: mysql> SHOW INDEX FROM sakila.film_text; +-----------+-----------------------+-------------+------------+ | Table | Key_name | Column_name | Index_type | +-----------+-----------------------+-------------+------------+ | ... | film_text | idx_title_description | title | FULLTEXT | | film_text | idx_title_description | description | FULLTEXT | +-----------+-----------------------+-------------+------------+
Hier ist ein Beispiel für eine natürlichsprachige Volltextsuchabfrage: mysql> SELECT film_id, title, RIGHT(description, 25), -> MATCH(title, description) AGAINST('factory casualties') AS relevance -> FROM sakila.film_text -> WHERE MATCH(title, description) AGAINST('factory casualties');
9 Häufig wird bei Tests der Fehler gemacht, einige Zeilen mit Beispieldaten in einen Volltextsuchindex zu setzen, nur um dann festzustellen, dass keine Abfrage einen Treffer ergibt. Das Problem besteht darin, dass jedes Wort in mehr als der Hälfte der Zeilen auftaucht.
264 | Kapitel 5: Erweiterte MySQL-Funktionen
+---------+-----------------------+---------------------------+-----------------+ | film_id | title | RIGHT(description, 25) | relevance | +---------+-----------------------+---------------------------+-----------------+ | 831 | SPIRITED CASUALTIES | a Car in A Baloon Factory | 8.4692449569702 | | 126 | CASUALTIES ENCINO | Face a Boy in A Monastery | 5.2615661621094 | | 193 | CROSSROADS CASUALTIES | a Composer in The Outback | 5.2072987556458 | | 369 | GOODFELLAS SALUTE | d Cow in A Baloon Factory | 3.1522686481476 | | 451 | IGBY MAKER | a Dog in A Baloon Factory | 3.1522686481476 |
MySQL führte die Volltextsuche aus, indem es den Suchstring in Wörter aufteilte und diese jeweils mit den title- und description-Feldern verglich, die in der Volltextsammlung kombiniert sind, auf der der Index aufbaut. Beachten Sie, dass nur eines der Ergebnisse beide Wörter enthält und dass die drei Ergebnisse, die »casualties« enthalten (es gibt nur drei in der gesamten Tabelle), zuerst aufgeführt werden. Das liegt daran, dass der Index die Ergebnisse nach absteigender Relevanz sortiert. Im Gegensatz zu normalen Abfragen werden die Ergebnisse der Volltextsuche automatisch nach der Relevanz sortiert. MySQL kann einen Index nicht für die Sortierung benutzen, wenn Sie eine Volltextsuche durchführen. Daher sollten Sie keine ORDER BY-Klausel angeben, wenn Sie einen Filesort vermeiden wollen.
Wie Sie in unserem Beispiel sehen können, gibt die MATCH( )-Funktion die Relevanz tatsächlich als Fließkommazahl zurück. Sie können diesen Wert verwenden, um nach der Relevanz zu filtern oder um die Relevanz in einer Benutzeroberfläche darzustellen. Es ergibt sich kein zusätzlicher Overhead, wenn man die MATCH( )-Funktion zweimal angibt; MySQL erkennt, dass die Funktionen gleich sind, und führt die Operation nur einmal durch. Falls Sie jedoch die MATCH( )-Funktion in eine ORDER BY-Klausel setzen, benutzt MySQL ein Filesort, um die Ergebnisse zu sortieren. Sie müssen die Spalten in der MATCH( )-Klausel exakt so angeben, wie sie in einem Volltextindex vorgegeben sind, da MySQL ansonsten den Index nicht verwenden kann. Schließlich zeichnet der Index nicht auf, in welcher Spalte ein Schlüsselwort aufgetaucht ist. Wie bereits erwähnt wurde, bedeutet das außerdem, dass Sie eine Volltextsuche nicht einsetzen können, um anzugeben, dass ein Schlüsselwort in einer bestimmten Spalte des Index stehen soll. Dafür gibt es jedoch eine Lösung: Sie können mit mehreren Volltextindizes in unterschiedlichen Kombinationen aus Spalten eine eigene Sortierung durchführen, um das gewünschte Ranking zu berechnen. Nehmen Sie an, wir wollen, dass die Titel-Spalte wichtiger ist. Fügen wir dieser Spalte einen weiteren Index hinzu: mysql> ALTER TABLE film_text ADD FULLTEXT KEY(title) ;
Jetzt können wir zum Zwecke des Rankings den Titel doppelt so wichtig machen: mysql> SELECT film_id, RIGHT(description, 25), -> ROUND(MATCH(title, description) AGAINST('factory casualties'), 3) -> AS full_rel, -> ROUND(MATCH(title) AGAINST('factory casualties'), 3) AS title_rel
Volltextsuche | 265
-> FROM sakila.film_text -> WHERE MATCH(title, description) AGAINST('factory casualties') -> ORDER BY (2 * MATCH(title) AGAINST('factory casualties')) -> + MATCH(title, description) AGAINST('factory casualties') DESC; +---------+---------------------------+----------+-----------+ | film_id | RIGHT(description, 25) | full_rel | title_rel | +---------+-------------- ------------+----------+-----------+ | 831 | a Car in A Baloon Factory | 8.469 | 5.676 | | 126 | Face a Boy in A Monastery | 5.262 | 5.676 | | 299 | jack in The Sahara Desert | 3.056 | 6.751 | | 193 | a Composer in The Outback | 5.207 | 5.676 | | 369 | d Cow in A Baloon Factory | 3.152 | 0.000 | | 451 | a Dog in A Baloon Factory | 3.152 | 0.000 | | 595 | a Cat in A Baloon Factory | 3.152 | 0.000 | | 649 | nizer in A Baloon Factory | 3.152 | 0.000 |
Dieser Ansatz ist allerdings nicht sehr effizient, da er Filesorts verursacht.
Boolesche Volltextsuchen Bei Booleschen Suchen gibt die Abfrage selbst die relative Relevanz der einzelnen Wörter in einem Treffer an. Boolesche Suchen benutzen die Stoppwortliste, um Stoppwörter auszufiltern. Die Notwendigkeit, dass Wörter länger als ft_min_word_len Zeichen und kürzer als ft_max_word_len Zeichen sind, ist hingegen deaktiviert. Die Ergebnisse sind unsortiert. Wenn Sie eine Boolesche Suchabfrage konstruieren, können Sie Präfixe benutzen, um die relative Rangfolge der einzelnen Schlüsselwörter in dem Suchstring zu verändern. Die gebräuchlichsten Modifikatoren sehen Sie in Tabelle 5-3. Tabelle 5-3: Gebräuchliche Modifikatoren für die Boolesche Volltextsuche Beispiel
Bedeutung
dinosaurier
Zeilen, die »dinosaurier« enthalten, werden höher eingeordnet.
~dinosaurier
Zeilen, die »dinosaurier« enthalten, werden niedriger eingeordnet.
+dinosaurier
Zeilen müssen »dinosaurier« enthalten.
-dinosaurier
Zeilen dürfen nicht »dinosaurier« enthalten.
dino*
Zeilen, die Wörter enthalten, die mit »dino« beginnen, werden höher eingeordnet.
Sie können auch andere Operatoren verwenden, etwa Klammern zum Gruppieren. Auf diese Weise lassen sich komplexe Suchen konstruieren. Als Beispiel wollen wir wieder in der Tabelle sakila.film_text nach Filmen suchen, die sowohl »factory« als auch »casualties« enthalten. Wie wir zuvor gesehen haben, liefert eine natürlichsprachige Suche Ergebnisse zurück, die entweder einem oder beiden Begriffen entsprechen. Nutzen wir dagegen eine Boolesche Suche, dann können wir darauf bestehen, dass beide Begriffe auftauchen müssen:
266 | Kapitel 5: Erweiterte MySQL-Funktionen
mysql> SELECT film_id, title, RIGHT(description, 25) -> FROM sakila.film_text -> WHERE MATCH(title, description) -> AGAINST('+factory +casualties' IN BOOLEAN MODE); +---------+---------------------+---------------------------+ | film_id | title | RIGHT(description, 25) | +---------+---------------------+---------------------------+ | 831 | SPIRITED CASUALTIES | a Car in A Baloon Factory | +---------+---------------------+---------------------------+
Sie können auch nach einer Wortgruppe suchen, indem Sie mehrere Wörter in Anführungszeichen setzen, so dass sie exakt so auftauchen müssen, wie sie in der Abfrage angegeben wurden: mysql> SELECT film_id, title, RIGHT(description, 25) -> FROM sakila.film_text -> WHERE MATCH(title, description) -> AGAINST('"spirited casualties"' IN BOOLEAN MODE); +---------+---------------------+---------------------------+ | film_id | title | RIGHT(description, 25) | +---------+---------------------+---------------------------+ | 831 | SPIRITED CASUALTIES | a Car in A Baloon Factory | +---------+---------------------+---------------------------+
Wortgruppensuchen sind oft ziemlich langsam. Der Volltextindex allein kann eine solche Abfrage nicht beantworten, weil er nicht verzeichnet, wo Wörter sich relativ zueinander in der Original-Volltextsammlung befinden. Daraus folgt, dass der Server tatsächlich in die Zeilen schauen muss, um eine Wortgruppensuche durchzuführen. Um eine solche Suche auszuführen, sucht der Server alle Dokumente, die sowohl »spirited« als auch »casualties« enthalten. Er holt dann die Zeilen, aus denen die Dokumente aufgebaut sind, und prüft, ob in der Sammlung die genaue Wortgruppe enthalten ist. Da er den Volltextindex benutzt, um die anfängliche Liste der passenden Dokumente zu suchen, könnten Sie denken, dass das sehr schnell ist – viel schneller als eine äquivalente LIKE-Operation. Um genau zu sein, ist es sehr schnell, solange die Wörter in der Wortgruppe ungewöhnlich sind und nicht sehr viele Ergebnisse aus dem Volltextindex an den Booleschen Vergleich zurückgeliefert werden. Wenn die Wörter in der Wortgruppe jedoch normal sind, kann LIKE viel schneller ablaufen, weil es die Zeilen sequenziell holt und nicht in einer quasizufälligen Indexreihenfolge und weil es nicht erst einen Volltextindex lesen muss. Eine Boolesche Volltextsuche verlangt nicht, dass ein Volltextindex in Aktion tritt. Sie benutzt einen Volltextindex, wenn einer vorhanden ist. Gibt es dagegen keinen, scannt sie einfach die gesamte Tabelle. Sie können eine Boolesche Volltextsuche sogar in Spalten aus mehreren Tabellen einsetzen, etwa in den Ergebnissen eines Joins. In all diesen Fällen ist sie allerdings langsam.
Volltextsuche | 267
Volltextänderungen seit MySQL 5.1 MySQL 5.1 brachte einige Änderungen in Bezug auf die Volltextsuche mit sich. Dazu gehören Leistungsverbesserungen und die Möglichkeit, zusätzliche Parser herzustellen und zu benutzen, die die vorhandenen Fähigkeiten verbessern. So können z.B. Plug-Ins die Funktionsweise der Indizierung verändern. Sie können Text viel flexibler als vorgegeben in Wörter aufteilen (indem Sie z.B. angeben, dass »C++« ein einziges Wort ist), eine Vorverarbeitung durchführen, unterschiedliche Inhaltstypen (wie etwa PDF) indizieren oder eigene Wortstamm-Techniken einsetzen. Die Plug-Ins können auch die Funktionsweise des Suchens beeinflussen – etwa indem Suchbegriffe auf Wortstämme zurückgeführt werden (»Stemming«). Die InnoDB-Entwickler arbeiten momentan an der Unterstützung für die Volltextindizierung, Wir wissen allerdings nicht, wann diese zur Verfügung stehen wird.
Volltextprobleme und -lösungen Die MySQL-Implementierung der Volltextsuche weist verschiedene Designbeschränkungen auf. Diese können bestimmten Zwecken zuwiderlaufen, es gibt allerdings viele Möglichkeiten, sie zu umgehen. Es gibt z.B. nur eine Form des Relevanz-Ranking bei der MySQL-Volltextindizierung: Häufigkeit. Der Index vermerkt nicht die Position des indizierten Wortes im String, so dass die Umgebung nichts zur Relevanz beiträgt. Das ist bei vielen Aufgaben zwar in Ordnung – vor allem, wenn es nur um kleine Datenmengen geht –, allerdings ist es möglicherweise nicht das, was Sie brauchen, und die MySQL-Volltextindizierung bietet Ihnen nicht die Flexibilität, einen anderen Ranking-Algorithmus zu wählen. (Sie speichert nicht einmal die Daten, die Sie für ein umgebungsbasiertes Ranking benötigen würden.) Größe ist ein weiteres Problem. Die MySQL-Volltextindizierung funktioniert prima, wenn der Index in den Speicher passt. Befindet sich der Index hingegen nicht im Speicher, kann sie sehr langsam sein, vor allem bei großen Feldern. Wenn Sie Wortgruppen suchen lassen, müssen sowohl die Daten als auch die Indizes in den Speicher passen, um eine gute Leistung zu erzielen. Verglichen mit anderen Indexarten, kann es sehr teuer sein, Zeilen in einen Volltextindex einzufügen, sie zu aktualisieren oder zu löschen: • Das Verändern eines Stücks Text mit 100 Wörtern erfordert nicht 1, sondern bis zu 100 Indexoperationen. • Die Feldlänge hat normalerweise bei anderen Indexarten keinen besonders starken Einfluss. Bei einer Volltextindizierung dagegen haben Text mit 3 Wörtern und Text mit 10.000 Wörtern Leistungsprofile, die sich um Größenordnungen unterscheiden. • Volltextsuchindizes sind außerdem viel anfälliger für Fragmentierung, so dass Sie vermutlich viel häufiger OPTIMIZE TABLE einsetzen müssen.
268 | Kapitel 5: Erweiterte MySQL-Funktionen
Volltextindizes beeinflussen auch, wie der Server Abfragen optimiert. Indexwahl, WHEREKlauseln und ORDER BY funktionieren anders, als Sie erwarten würden: • Wenn es einen Volltextindex gibt und die Abfrage eine MATCH AGAINST-Klausel enthält, die sie benutzen kann, verwendet MySQL den Volltextindex, um die Abfrage zu verarbeiten. Es vergleicht den Volltextindex nicht mit den anderen Indizes, die für die Abfrage benutzt werden könnten. Einige dieser anderen Indizes sind vielleicht für die Abfrage sogar besser, aber MySQL beachtet sie nicht. • Der Volltextsuchindex kann nur Volltextvergleiche durchführen. Alle anderen Kriterien in der Abfrage, wie etwa WHERE-Klauseln, müssen angewandt werden, nachdem MySQL die Zeile aus der Tabelle gelesen hat. Dieses Verhalten ist anders als das anderer Indexarten, mit denen man mehrere Teile einer WHERE-Klausel auf einmal prüfen kann. • Volltextindizes speichern nicht den eigentlichen Text, den sie indizieren. Das heißt, Sie können einen Volltextindex niemals als abdeckenden Index benutzen. • Volltextindizes können nicht für irgendeine Art von Sortierung benutzt werden, außer für die Sortierung nach Relevanz im natürlichsprachigen Modus. Falls Sie nach einem anderen Kriterium als der Relevanz sortieren müssen, benutzt MySQL ein Filesort. Schauen wir uns an, wie diese Einschränkungen die Abfragen beeinflussen. Nehmen Sie einmal an, Sie haben eine Million Dokumente mit einem normalen Index über den Dokumentautor und einem Volltextindex im Inhalt. Sie wollen eine Volltextsuche im Dokumenteninhalt durchführen, allerdings nur für Autor 123. Die Abfrage könnten Sie folgendermaßen schreiben: ... WHERE MATCH(content) AGAINST ('High Performance MySQL') AND author = 123;
Diese erste Abfrage ist jedoch sehr ineffizient. MySQL durchsucht zuerst die eine Million Dokumente, weil es den Volltextindex bevorzugt. Anschließend wendet es die WHEREKlausel an, um die Ergebnisse auf den angegebenen Autor einzuschränken. Allerdings ist diese Filteroperation nicht in der Lage, den Index im Autor einzusetzen. Eine Lösung besteht darin, die Autoren-IDs in den Volltextindex aufzunehmen. Sie können ein Präfix wählen, das mit hoher Wahrscheinlichkeit nicht im Text auftauchen wird, dann die ID des Autors daran anhängen und dieses »Wort« in eine filters-Spalte aufnehmen, die separat gepflegt wird (möglicherweise über einen Trigger). Anschließend erweitern Sie den Volltextindex so, dass er die filters-Spalte enthält, und schreiben die Abfrage folgendermaßen um: ... WHERE MATCH(content, filters) AGAINST ('High Performance MySQL +author_id_123' IN BOOLEAN MODE);
Das könnte effizienter sein, wenn die Autoren-ID sehr selektiv ist, da MySQL die Liste der Dokumente schnell einschränken kann, indem der Volltextindex nach »author_id_ 123« durchsucht wird. Ist die ID dagegen nicht sehr selektiv, könnte die Leistung sogar schlechter sein. Seien Sie also vorsichtig mit diesem Ansatz.
Volltextsuche | 269
Manchmal lassen sich Volltextindizes auch für Bounding-Box-Suchen einsetzen. Falls Sie z.B. die Suche auf einen Bereich aus Koordinaten (für Geo-Anwendungen) beschränken wollen, können Sie die Koordinaten in der Volltextsammlung kodieren. Nehmen Sie an, die Koordinaten für eine bestimmte Zeile sind X=123 und Y=456. Sie können die Koordinaten so schachteln, dass die wichtigsten Stellen zuerst kommen, also etwa XY142536, und sie dann in eine Spalte setzen, die in den Volltextindex aufgenommen wird. Wenn Sie nun die Suchen z.B. auf ein Rechteck beschränken wollen, das in X-Richtung zwischen 100 und 199 und in Y-Richtung zwischen 400 und 499 liegt, dann können Sie »+XY14*« zu der Suchabfrage hinzufügen. Das geht möglicherweise viel schneller als die Filterung mit einer WHERE-Klausel. Eine Technik, die manchmal gut mit Volltextindizes funktioniert, besonders bei paginierten Darstellungen, besteht darin, eine Liste mit Primärschlüsseln über eine Volltextabfrage auszuwählen und die Ergebnisse dann im Cache abzulegen. Wenn die Anwendung bereit ist, einige Ergebnisse darzustellen, kann sie eine weitere Abfrage ausführen, die die gewünschten Zeilen anhand ihrer IDs holt. Diese zweite Abfrage kann kompliziertere Kriterien oder Joins enthalten, die andere Indizes benötigen, um gut zu funktionieren. Zwar unterstützt nur MyISAM Volltextindizes, Sie müssen sich aber dennoch keine Sorgen machen, falls Sie stattdessen InnoDB oder eine andere Storage-Engine benutzen müssen. Eine gebräuchliche Methode ist, Ihre Tabellen auf einen Slave zu replizieren, dessen Tabellen die MyISAM-Storage-Engine benutzen, und dann die Volltextabfragen auf dem Slave zu erledigen. Falls Sie keine Abfragen auf einem anderen Server durchführen wollen, können Sie die Tabelle vertikal partitionieren, indem Sie sie in zwei Tabellen aufteilen, wobei Sie die Textspalten von den restlichen Daten trennen. Sie können auch einige Spalten in eine Tabelle duplizieren, die volltextindiziert ist. Diese Strategie kommt in der Tabelle sakila.film_text zum Einsatz, die mit Triggern gepflegt wird. Eine weitere Alternative besteht darin, eine externe Volltextsuchmaschine zu verwenden, wie etwa Lucene oder Sphinx. Mehr über Sphinx erfahren Sie in Anhang C. GROUP BY-Abfragen mit Volltextsuchen können tödlich für die Leistung sein, weil auch hier die Volltextabfrage typischerweise viele Treffer findet; diese verursachen zufällige Plattenzugriffe, gefolgt von einer temporären Tabelle oder einem Filesort für die Gruppierung. Da solche Abfragen oft einfach nur nach den obersten Elementen einer Gruppe suchen, besteht eine gute Optimierung darin, die Ergebnisse stichprobenartig auszugeben, anstatt zu versuchen, völlig akkurat zu sein. Holen Sie z.B. die ersten 1.000 Zeilen in eine temporäre Tabelle, und liefern Sie dann das oberste Ergebnis pro Gruppe aus dieser Tabelle zurück.
Volltexteinstellung und -optimierung Um die Leistung zu verbessern, ist die regelmäßige Pflege Ihrer Volltextindizes unerlässlich. Die Doppel-B-Baum-Struktur der Volltextindizes in Kombination mit der großen Anzahl der Schlüsselwörter in typischen Dokumenten bedeutet, dass Volltextindizes
270 | Kapitel 5: Erweiterte MySQL-Funktionen
stärker unter Fragmentierung leiden als normale Indizes. Benutzen Sie oft OPTIMIZE TABLE, um die Indizes zu defragmentieren. Falls Ihr Server ein-/ausgabegebunden ist, könnte es schneller sein, die Volltextindizes regelmäßig zu verwerfen und neu zu erzeugen. Ein Server, der Volltextsuchen gut ausführen soll, benötigt Schlüsselpuffer, die groß genug sind, um die Volltextindizes aufzunehmen, da diese viel besser funktionieren, wenn sie sich im Speicher befinden. Sie können spezielle Schlüsselpuffer einsetzen, um sicherzugehen, dass andere Indizes Ihre Volltextindizes nicht aus dem Schlüsselpuffer verdrängen. In »Der MyISAM-Schlüssel-Cache« auf Seite 296 finden Sie nähere Informationen über die MyISAM-Schlüsselpuffer. Es ist außerdem wichtig, eine gute Stoppwortliste anzugeben. Die Vorgaben funktionieren ganz gut mit englischer Prosa, eignen sich aber vermutlich nicht für andere Sprachen oder spezialisierte Texte, wie etwa technische Dokumente. Falls Sie z.B. ein Dokument über MySQL indizieren, werden Sie »mysql« in die Stoppwortliste aufnehmen, weil es zu oft vorkommt, um eine Hilfe zu sein. Sie können die Leistung meist verbessern, indem Sie kurze Wörter auslassen. Die Länge lässt sich mit dem Parameter ft_min_word_len konfigurieren. Vergrößern Sie den Standardwert, werden mehr Wörter übersprungen, wodurch der Index kleiner und schneller, aber auch weniger genau wird. Denken Sie auch daran, dass Sie für besondere Zwecke möglicherweise sehr kurze Wörter benötigen. Beispielsweise würde eine Suche nach Heimelektronik bei der Abfrage »CD Player« wahrscheinlich viele irrelevante Ergebnisse liefern, wenn kurze Wörter im Index nicht erlaubt wären. Ein Anwender, der nach »CD Player« sucht, möchte in den Ergebnissen keine MP3- und DVD-Player finden. Wenn die minimale Wortlänge aber die vorgegebenen vier Zeichen beträgt, wird eigentlich nur nach »Player« gesucht, so dass alle Arten von Abspielgeräten mit dieser Bezeichnung zurückgeliefert werden. Die Stoppwortliste und die minimale Wortlänge können die Suchgeschwindigkeit verbessern, indem einige Wörter aus dem Index herausgehalten werden. Darunter kann allerdings die Suchqualität leiden. Die richtige Wahl ist abhängig von der Anwendung. Wenn Sie eine gute Performance und hochwertige Ergebnisse benötigen, müssen Sie beide Parameter für Ihre Anwendung anpassen. Es bietet sich an, irgendeine Art von Logging einzubauen und dann gebräuchliche Suchen, ungebräuchliche Suchen, Suchen, die keine Ergebnisse liefern, und Suchen, die viele Ergebnisse liefern, zu untersuchen. Auf diese Weise gewinnen Sie Erkenntnisse über Ihre Benutzer und Ihre suchbaren Inhalte. Mit diesen Erkenntnissen lassen sich dann die Performance und die Qualität Ihrer Suchergebnisse verbessern. Falls Sie die minimale Wortlänge ändern, müssen Sie den Index mit OPTIMIZE TABLE neu aufbauen, damit die Änderung wirksam wird. Ein verwandter Parameter ist ft_max_word_len, der hauptsächlich als Sicherheitsvorkehrung dient, um die Indizierung sehr langer Schlüsselwörter zu vermeiden.
Volltextsuche | 271
Wenn Sie viele Daten in einen Server importieren und in einigen Spalten eine Volltextindizierung durchführen wollen, dann deaktivieren Sie die Volltextindizes vor dem Import mit DISABLE KEYS, und aktivieren Sie sie hinterher wieder mit ENABLE KEYS. Das geht normalerweise wegen der hohen Kosten für das Aktualisieren des Index bei jeder eingefügten Zeile viel schneller, und darüber hinaus erhalten Sie als nette Zugabe einen defragmentierten Index. Bei großen Datenmengen müssen Sie eventuell die Daten manuell auf viele Knoten aufteilen und sie parallel suchen. Das ist eine schwierige Aufgabe, für die Sie vielleicht besser eine externe Volltextsuchmaschine wie Lucene oder Sphinx einsetzen sollten. Unsere Erfahrungen haben gezeigt, dass Sie damit eine um Größenordnungen bessere Performance erreichen.
Fremdschlüsselbeschränkungen InnoDB ist momentan die Storage-Engine, die Fremdschlüssel in MySQL unterstützt, wodurch Ihre Auswahl an Storage-Engines für diesen Fall doch ziemlich eingeschränkt ist.10 Die Firma MySQL AB hat allerdings versprochen, dass der Server selbst irgendwann Fremdschlüssel unterstützen wird, die unabhängig von der Storage-Engine sind. Momentan sieht es allerdings so aus, als würde InnoDB noch für einige Zeit allein auf weiter Flur bleiben. Wir konzentrieren uns deshalb auf Fremdschlüssel in InnoDB. Fremdschlüssel sind nicht frei. Sie erfordern es typischerweise, dass der Server jedes Mal einen Lookup in einer anderen Tabelle ausführt, wenn Sie Daten ändern. Obwohl InnoDB einen Index verlangt, um diese Operation zu beschleunigen, sind die Auswirkungen dieser Überprüfungen spürbar. Sie können sogar zu einem sehr großen Index mit scheinbar keiner Selektivität führen. Nehmen Sie z.B. an, dass Sie eine status-Spalte in einer riesigen Tabelle haben und den Status auf gültige Werte beschränken wollen. Allerdings gibt es nur drei solcher Werte. Der zusätzliche Index, der verlangt wird, kann die Gesamtgröße der Tabelle deutlich erhöhen – sogar dann, wenn die Spalte selbst klein ist, und besonders dann, wenn der Primärschlüssel groß ist – und ist für alles andere als Fremdschlüsselüberprüfungen nicht zu gebrauchen. Dennoch können Fremdschlüssel die Leistung in einigen Fällen verbessern. Wenn Sie garantieren müssen, dass zwei verwandte Tabellen konsistente Daten aufweisen, kann es effizienter sein, den Server diese Überprüfung durchführen zu lassen, als dies in Ihrer Anwendung zu erledigen. Fremdschlüssel sind auch bei gestaffelten Lösch- oder UpdateVorgängen hilfreich, obwohl sie zeilenweise arbeiten und damit langsamer sind als Mehrtabellen-Lösch- oder Batch-Operationen. Fremdschlüssel können Ihre Abfrage veranlassen, in andere Tabellen »hinüberzulangen«, was bedeutet, dass Sperren gesetzt werden. Wenn Sie z.B. eine Zeile in eine Kindtabelle einfügen, veranlasst die Fremdschlüsselbeschränkung InnoDB, in der Elterntabelle nach 10 PBXT unterstützt sie auch.
272 | Kapitel 5: Erweiterte MySQL-Funktionen
einem dazugehörenden Wert zu suchen. Außerdem muss die Zeile in der Elterntabelle gesperrt werden, damit diese nicht gelöscht wird, bevor die Transaktion abgeschlossen ist. Dies kann die Ursache für unerwartete Lock-Wartezustände und sogar Deadlocks in Tabellen sein, die Sie eigentlich gar nicht direkt anfassen. Solche Probleme sind unter Umständen schwer zu finden und zu beseitigen. Manchmal können Sie anstelle von Fremdschlüsseln Trigger benutzen. Fremdschlüssel sind bei Aufgaben wie gestaffelten Updates besser als Trigger. Allerdings lässt sich ein Fremdschlüssel, der nur als Beschränkung verwendet wird, wie in unserem status-Beispiel, effizienter in einen Trigger mit einer expliziten Liste der erlaubten Werte umschreiben. (Sie können auch einfach einen ENUM-Datentyp einsetzen.) Anstatt Fremdschlüssel als Beschränkungen zu benutzen, ist es oft besser, die Werte in der Anwendung zu beschränken.
Merge-Tabellen und Partitionierung Merge-Tabellen und Partitionierung sind verwandte Konzepte, deren Unterschied verwirrend sein kann. Merge-Tabellen sind eine MySQL-Eigenschaft, die mehrere MyISAMTabellen in einer einzigen »virtuellen Tabelle« kombiniert, etwa wie eine Sicht, die ein UNION über die Tabellen ausführt. Sie erzeugen eine Merge-Tabelle mit der Merge-Storage-Engine. Eine Merge-Tabelle ist eigentlich keine echte Tabelle; stellen Sie sie sich eher wie einen Container für ähnlich definierte Tabellen vor. Im Gegensatz dazu scheinen partitionierte Tabellen normale Tabellen zu sein, die besondere Anweisungen enthalten, mit denen MySQL mitgeteilt wird, wo die Zeilen physisch gespeichert werden sollen. Das schmutzige kleine Geheimnis lautet, dass der Speichercode für partitionierte Tabellen stark dem Code für Merge-Tabellen ähnelt! Um genau zu sein, ist jede Partition auf einer niedrigen Ebene einfach nur eine eigene Tabelle mit eigenen Indizes; die partitionierte Tabelle ist ein Wrapper um eine Sammlung von HandlerObjekten herum. Eine partitionierte Tabelle sieht wie eine einzige Tabelle aus und verhält sich auch so, hinter den Kulissen handelt es sich jedoch um ein ganzes Bündel separater Tabellen. Es gibt allerdings keine Möglichkeit, wie bei Merge-Tabellen direkt auf die zugrunde liegenden Tabellen zuzugreifen. Partitionierung ist eine neue Funktion in MySQL 5.1, Merge-Tabellen dagegen gibt es schon lange. Beide haben zum Teil die gleichen Vorteile. Sie können damit: • statische und sich ändernde Daten trennen • die physische Nachbarschaft verwandter Daten nutzen, um Abfragen zu optimieren • Ihre Tabellen so gestalten, dass Abfragen auf weniger Daten zugreifen • sehr große Datenmengen leichter pflegen (Das ist ein Bereich, in dem Merge-Tabellen Vorteile gegenüber partitionierten Tabellen aufweisen.) Da die MySQL-Implementierungen von Partitionierung und Merge-Tabellen vieles gemeinsam haben, weisen sie auch teilweise die gleichen Einschränkungen auf. Beispiels-
Merge-Tabellen und Partitionierung | 273
weise gibt es praktische Grenzen hinsichtlich der Anzahl der zugrunde liegenden Tabellen oder Partitionen, die Sie in einer einzigen Merge- oder partitionierten Tabelle haben können. In den meisten Fällen wird es bei einigen Hundert Tabellen langsam ineffizient. Wir erwähnen die Beschränkungen der beiden Systeme, wenn wir sie genauer vorstellen.
Merge-Tabellen Sie können sich Merge-Tabellen als eine ältere, beschränktere Version der Partitionierung vorstellen. Sie haben aber dennoch ihren Nutzen und bieten Eigenschaften, die Partitionen nicht haben. Die Merge-Tabelle ist eigentlich ein Container, der die echten Tabellen aufnimmt. Sie geben mit einer speziellen UNION-Syntax in CREATE TABLE an, welche Tabellen aufgenommen werden sollen. Hier ist ein Beispiel, das viele Aspekte von Merge-Tabellen demonstriert: mysql> CREATE TABLE t1(a INT NOT NULL PRIMARY KEY)ENGINE=MyISAM; mysql> CREATE TABLE t2(a INT NOT NULL PRIMARY KEY)ENGINE=MyISAM; mysql> INSERT INTO t1(a) VALUES(1),(2); mysql> INSERT INTO t2(a) VALUES(1),(2); mysql> CREATE TABLE mrg(a INT NOT NULL PRIMARY KEY) -> ENGINE=MERGE UNION=(t1, t2) INSERT_METHOD=LAST; mysql> SELECT a FROM mrg; +------+ | a | +------+ | 1 | | 1 | | 2 | | 2 | +------+
Beachten Sie, dass die zugrunde liegenden Tabellen exakt die gleiche Anzahl und Art von Spalten enthalten und dass alle Indizes, die in der Merge-Tabelle existieren, auch in den zugrunde liegenden Tabellen vorhanden sind. Das ist notwendig, wenn Sie eine MergeTabelle erzeugen. Beachten Sie außerdem, dass es einen Primärschlüssel in der einzigen Spalte jeder Tabelle gibt, dass die resultierende Merge-Tabelle jedoch duplizierte Zeilen aufweist. Dies ist eine der Beschränkungen von Merge-Tabellen: Die einzelnen Tabellen innerhalb des Merge verhalten sich normal, die Merge-Tabelle erzwingt allerdings keine Beschränkungen über die ganze Gruppe von Tabellen. Die Anweisung INSERT_METHOD=LAST an die Tabelle teilt MySQL mit, dass es alle INSERTAnweisungen an die letzte Tabelle in dem Merge senden soll. Die Angabe von FIRST oder LAST ist Ihre einzige Möglichkeit, zu steuern, wo die Zeilen, die in die Merge-Tabelle eingefügt werden, platziert werden (Sie können jedoch weiterhin direkt in die zugrunde liegenden Tabellen einfügen). Partitionierte Tabellen bieten mehr Kontrolle darüber, wo die Daten gespeichert werden.
274 | Kapitel 5: Erweiterte MySQL-Funktionen
Die Ergebnisse eines INSERT sind sowohl in der Merge-Tabelle als auch in der zugrunde liegenden Tabelle sichtbar: mysql> INSERT INTO mrg(a) VALUES(3); mysql> SELECT a FROM t2; +---+ | a | +---+ | 1 | | 2 | | 3 | +---+
Merge-Tabellen haben einige weitere interessante Funktionen und Beschränkungen. Was geschieht z.B., wenn Sie eine Merge-Tabelle oder eine ihrer zugrunde liegenden Tabellen verwerfen? Wird eine Merge-Tabelle verworfen, dann bleiben ihre »Kind«-tabellen davon unberührt. Wird dagegen eine der Kindtabellen verworfen, hat das andere Auswirkungen, die vom Betriebssystem abhängen. Unter GNU/Linux bleibt z.B. der Dateideskriptor der zugrunde liegenden Tabelle offen, und die Tabelle existiert weiter, wenn auch nur über die Merge-Tabelle: mysql> DROP TABLE t1, t2; mysql> SELECT a FROM mrg; +------+ | a | +------+ | 1 | | 1 | | 2 | | 2 | | 3 | +------+
Es gibt noch eine Vielzahl weiterer Beschränkungen und besonderer Verhaltensweisen. Näheres erfahren Sie aus dem Handbuch. Wir wollen zumindest noch anmerken, dass REPLACE in einer Merge-Tabelle nicht funktioniert und dass AUTO_INCREMENT anders funktioniert, als Sie erwarten würden.
Auswirkungen von Merge-Tabellen auf die Performance Die Art und Weise, wie MySQL Merge-Tabellen implementiert, hat wichtige Folgen für die Leistung. Das macht sie für manche Anwendungsfälle besser geeignet als für andere. Hier sind einige Aspekte von Merge-Tabellen, die Sie bedenken sollten: • Eine Merge-Tabelle verlangt mehr offene Dateideskriptoren als eine Nicht-MergeTabelle, die die gleichen Daten enthält. Obwohl eine Merge-Tabelle wie eine einzige Tabelle aussieht, öffnet sie die zugrunde liegenden Tabellen separat. Daraus folgt, das ein einziger Tabellen-Cache-Eintrag viele Dateideskriptoren erzeugen kann. Das heißt: Selbst wenn Sie den Tabellen-Cache so konfiguriert haben, dass er Ihren Server vor der Ausweitung der Dateideskriptorgrenzen pro Prozess Ihres Betriebssystems schützt, können Merge-Tabellen dazu führen, dass diese Grenze überschritten wird.
Merge-Tabellen und Partitionierung | 275
• Die CREATE-Anweisung, die eine Merge-Tabelle erzeugt, überprüft nicht, ob die zugrunde liegenden Tabellen kompatibel sind. Sind die zugrunde liegenden Tabellen unterschiedlich definiert, könnte MySQL eine Merge-Tabelle erzeugen, die es später gar nicht nutzen kann. Falls Sie eine der zugrunde liegenden Tabellen ändern, nachdem Sie eine gültige Merge-Tabelle erzeugt haben, hört diese auf zu funktionieren, und Sie erhalten folgende Fehlermeldung: »ERROR 1168 (HY000): Unable to open underlying table which is differently defined or of non-MyISAM type or doesn’t exist«. • Abfragen, die auf die Merge-Tabelle zugreifen, greifen auf jede zugrunde liegende Tabelle zu. Dadurch können einzeilige Schlüsselsuchen, verglichen mit einem Lookup in einer einzigen Tabelle, sehr langsam sein. Es ist deshalb keine schlechte Idee, die Anzahl der zugrunde liegenden Tabellen in einer Merge-Tabelle zu begrenzen, vor allem, wenn sie die zweite oder eine spätere Tabelle in einem Join ist. Auf je weniger Daten Sie mit jeder Operation zugreifen, umso wichtiger werden die Kosten für den Zugriff auf die einzelnen Tabellen in Bezug auf die gesamte Operation. Folgendes sollten Sie beachten, wenn Sie planen, wie Sie Merge-Tabellen benutzen wollen: • Bereichs-Lookups sind weniger von dem Aufwand betroffen, der beim Zugriff auf alle zugrunde liegenden Tabellen auftritt, als Lookups nach einzelnen Elementen. • Tabellenscans sind in Merge-Tabellen fast genauso schnell wie in normalen Tabellen. • Lookups nach eindeutigen Schlüsseln und Primärschlüsseln stoppen, sobald sie erfolgreich sind. In diesem Fall greift der Server nacheinander auf die zugrunde liegenden Merge-Tabellen zu, bis ein Wert gefunden wird. Anschließend wird nicht auf weitere Tabellen zugegriffen. • Die zugrunde liegenden Tabellen werden in der Reihenfolge gelesen, die in der CREATE TABLE-Anweisung angegeben ist. Wenn Sie oft Daten in einer bestimmten Reihenfolge benötigen, können Sie diese Tatsache ausnutzen, um die Merge-Sortieroperation zu beschleunigen.
Stärken von Merge-Tabellen Merge-Tabellen sind besonders gut für Daten geeignet, die natürlicherweise einen aktiven und einen inaktiven Teil aufweisen. Ein klassisches Beispiel ist das Logging. An Logs wird üblicherweise nur etwas angehängt, man könnte also ein Schema wie »eine Tabelle pro Tag« wählen. Jeden Tag würde man eine neue zugrunde liegende Tabelle erzeugen und entsprechend in die Merge-Tabelle aufnehmen. Die Tabelle des vorhergehenden Tages könnte man aus der Merge-Tabelle entfernen, sie in komprimiertes MyISAM umwandeln und dann wieder einfügen.
276 | Kapitel 5: Erweiterte MySQL-Funktionen
Das ist jedoch nicht der einzige Anwendungsfall für Merge-Tabellen. Sie kommen oft in Data-Warehousing-Anwendungen zum Einsatz, da eine ihrer weiteren Stärken die Art und Weise ist, wie sie bei der Verwaltung riesiger Datenmengen helfen. Es ist praktisch unmöglich, eine einzige Tabelle mit Terabytes an Daten zu verwalten. Diese Aufgabe lässt sich viel leichter bewältigen, wenn es sich um eine Merge-Sammlung aus 50-GByteTabellen handelt. Wenn Sie extrem große Datenbanken verwalten, müssen Sie nicht nur an normale Operationen denken, sondern auch Szenarien für Abstürze und Wiederherstellung entwickeln. Es ist sinnvoll, Tabellen nach Möglichkeit klein zu halten. Eine Sammlung kleiner Tabellen lässt sich viel schneller überprüfen und reparieren als eine riesige Tabelle, vor allem, wenn die riesige Tabelle nicht in den Speicher passt. Bei mehreren Tabellen können Sie Überprüfung und Reparatur sogar parallel durchführen. Ein weiteres Anliegen beim Data-Warehousing ist die Frage, wie alte Daten beseitigt werden. Der Einsatz von DELETE zum Entfernen von Zeilen aus einer riesigen Tabelle ist im besten Fall ineffizient und im schlimmsten Fall katastrophal. Andererseits ist es sehr einfach, die Definition einer Merge-Tabelle zu ändern und DROP TABLE einzusetzen, um alte Daten loszuwerden. Sie können das leicht automatisieren. Merge-Tabellen sind nicht nur für das Logging und für riesige Datenmengen von Nutzen. Sie eignen sich auch zum bedarfsweisen Erzeugen von Tabellen. Das Erzeugen und Verwerfen von Merge-Tabellen ist recht unaufwendig, so dass Sie sie ungefähr wie Sichten mit UNION ALL benutzen können; der Overhead ist jedoch geringer, da der Server die Ergebnisse nicht in einer temporären Tabelle zwischenspeichert, bevor er sie an den Client sendet. Dadurch eignen sie sich sehr gut für die Anforderungen des Reportings und des Data-Warehousings. So können Sie z.B. einen nächtlichen Job anlegen, der die Daten von gestern mit den Daten von vor 8 Tagen, von vor 15 Tagen usw. in einem Merge zusammenfasst, um so wochenweise Berichte zu ermöglichen. Auf diese Weise können Ihre Berichtsabfragen ohne Modifikationen ausgeführt werden und automatisch auf die passenden Daten zugreifen. Sie können sogar temporäre Merge-Tabellen herstellen – was mit Sichten nicht geht. Da Merge-Tabellen die zugrunde liegenden MyISAM-Tabellen nicht verbergen, bieten sie Eigenschaften, die Partitionen nicht haben: • Eine MyISAM-Tabelle kann Mitglied in vielen Merge-Tabellen sein. • Sie können die zugrunde liegenden Tabellen zwischen Servern kopieren, indem Sie die .frm-, .MYI- und .MYD-Dateien kopieren. • Sie können zu einer Merge-Sammlung leicht weitere Tabellen hinzufügen; erzeugen Sie dazu einfach eine neue Tabelle, und ändern Sie die Merge-Definition. • Sie können temporäre Merge-Tabellen erzeugen, die nur die gewünschten Daten enthalten, etwa Daten aus einem speziellen Zeitraum, was mit Partitionen nicht möglich ist.
Merge-Tabellen und Partitionierung | 277
• Sie können eine Tabelle aus der Merge-Tabelle entfernen, falls Sie sie sichern, wiederherstellen, reparieren oder andere Operationen auf ihr ausführen wollen. Wenn Sie fertig sind, fügen Sie sie einfach wieder ein. • Mit myisampack können Sie einige oder alle zugrunde liegenden Tabellen komprimieren. Im Gegensatz dazu werden die Partitionen einer partitionierten Tabelle vom MySQL-Server verborgen und können nur über die partitionierte Tabelle erreicht werden.
Partitionierte Tabellen Die MySQL-Implementierung der Partitionierung ähnelt hinter den Kulissen stark der Implementierung der Merge-Tabellen. Sie ist allerdings stark in den Server integriert und weist einen wesentlichen Unterschied zu den Merge-Tabellen auf: Jede Datenzeile darf nur in einer der Partitionen gespeichert werden. Die Definition der Tabelle legt fest, welche Zeilen zu welchen Partitionen gehören. Diese Angabe beruht auf einer Partitionierungsfunktion, die wir später erklären. Primärschlüssel und eindeutige Schlüssel funktionieren also wie erwartet in der ganzen Tabelle, und der MySQL-Abfrageoptimierer kann Abfragen an partitionierte Tabellen viel intelligenter optimieren als an MergeTabellen. Hier sind einige wichtige Vorteile von partitionierten Tabellen: • Sie können angeben, dass bestimmte Zeilen zusammen in einer Partition gespeichert werden, wodurch sich die Datenmenge vermindert, die der Server untersuchen muss, und Abfragen sich beschleunigen. Falls Sie z.B. nach dem Datenbereich partitionieren und dann in einem Datenbereich eine Abfrage ausführen, der nur auf eine Partition zugreift, liest der Server nur diese Partition. • Partitionierte Daten lassen sich leichter pflegen als nichtpartitionierte Daten. Außerdem ist es einfacher, alte Daten loszuwerden, indem man eine ganze Partition verwirft. • Partitionierte Daten können physisch verteilt werden, wodurch der Server in die Lage versetzt wird, mehrere Festplatten effizienter einzusetzen. Die MySQL-Implementierung der Partitionierung ist noch im Fluss. Sie ist außerdem zu kompliziert, um sie hier ganz genau zu erklären. Wir wollen uns auf ihre Auswirkungen auf die Performance konzentrieren, weshalb wir Sie für die Grundlagen auf das MySQLHandbuch verweisen, das eine Menge Material zu diesem Thema bereithält. Sie sollten das ganze Kapitel über die Partitionierung lesen und sich dann noch die Abschnitte über CREATE TABLE, SHOW CREATE TABLE, ALTER TABLE, die INFORMATION_SCHEMA.PARTITIONS-Tabelle und EXPLAIN anschauen. Die Partitionierung hat dafür gesorgt, dass die Befehle CREATE TABLE und ALTER TABLE deutlich komplexer wurden. Genau wie eine Merge-Tabelle besteht eine partitionierte Tabelle eigentlich aus einer Sammlung separater Tabellen (den Partitionen) mit separaten Indizes auf der StorageEngine-Ebene. Das bedeutet, dass der Speicher und die Anforderungen an die Datei278 | Kapitel 5: Erweiterte MySQL-Funktionen
deskriptoren für eine partitionierte Tabelle mit denen einer Merge-Tabelle vergleichbar sind. Allerdings kann man auf die Partitionen nicht unabhängig von der Tabelle zugreifen, außerdem kann jede Partition nur zu einer Tabelle gehören. Wie bereits angemerkt wurde, benutzt MySQL eine Partitionierungsfunktion, um zu entscheiden, welche Zeilen in welchen Partitionen gespeichert werden. Die Funktion muss einen nichtkonstanten, deterministischen Integer-Wert zurückliefern. Es gibt mehrere Arten der Partitionierung. Die Bereichspartitionierung richtet für jede Partition einen Bereich von Werten ein und weist dann auf der Grundlage der Bereiche, in die sie fallen, Zeilen zu Partitionen zu. MySQL unterstützt auch Schlüssel-, Hash- und Listenpartitionierungsmethoden. Jeder Typ hat seine Stärken und Schwächen. Einige der Typen sind auch Beschränkungen unterworfen, speziell wenn es um den Umgang mit Primärschlüsseln geht.
Wieso die Partitionierung funktioniert Der Schlüssel zum Entwerfen partitionierter Tabellen in MySQL besteht darin, sich die Partitionierung als eine grobkörnige Art von Indizierung vorzustellen. Nehmen Sie einmal an, Sie haben eine Tabelle mit einer Milliarde Zeilen historischer, tage- und objektweise aufgenommener Verkaufsdaten, und jede Zeile ist relativ groß – sagen wir 500 Byte. Sie fügen neue Zeilen ein, aktualisieren existierende Zeilen aber nie und führen hauptsächlich Abfragen aus, die Bereiche mit Daten untersuchen. Das Hauptproblem beim Ausführen von Abfragen an dieser Tabelle besteht darin, dass sie riesig ist: Sie ist fast ein halbes Terabyte groß – ohne Indizes –, wenn Sie die Daten nicht komprimieren. Ein Ansatz zum Beschleunigen der tageweisen Abfragen könnte darin bestehen, einen Primärschlüssel in (day, itemno) hinzuzufügen und InnoDB zu benutzen. Damit werden die Daten der einzelnen Tage physisch gruppiert, so dass die Bereichsabfragen weniger Daten zu untersuchen haben. Alternativ könnten Sie MyISAM benutzen und die Zeilen in der gewünschten Reihenfolge einfügen, damit ein Indexscan nicht so viele zufällige Ein-/Ausgaben verursacht. Eine andere Möglichkeit wäre es, den Primärschlüssel wegzulassen und die Daten anhand des Tages zu partitionieren. Jede Abfrage, die auf Bereiche aus Tagen zugreift, muss ganze Partitionen scannen. Das könnte aber in einer solch riesigen Tabelle besser sein, als Index-Lookups durchzuführen. Die Partitionierung ist ein bisschen wie ein Index: Sie teilt MySQL ungefähr mit, wo eine bestimmte Zeile zu finden ist, wenn Sie den Tag kennen. Dabei belegt sie aber fast keinen Plattenplatz oder Speicher, da die Partitionierung nicht exakt auf die Zeile zeigt (wie es ein Index tut). Lassen Sie sich jedoch nicht dazu hinreißen, einen Primärschlüssel und eine Partition hinzuzufügen – damit könnten Sie die Performance sogar herabsetzen, vor allem bei Abfragen, die auf alle Partitionen zugreifen müssen. Wenn Sie über Partitionierung nachdenken, sollten Sie sorgfältig Benchmark-Tests durchführen, weil partitionierte Tabellen die Leistung nicht immer verbessern.
Merge-Tabellen und Partitionierung | 279
Beispiele für Partitionierung Wir zeigen Ihnen hier zwei kurze Beispiele, bei denen die Partitionierung hilfreich ist. Zuerst wollen wir uns anschauen, wie man eine partitionierte Tabelle gestaltet, um datumsbasierte Daten zu speichern. Nehmen Sie an, Sie haben Leistungsstatistiken für Bestellungen und Verkäufe von Produkten gesammelt. Da Sie oft Abfragen in Bereichen aus Daten durchführen, setzen Sie das Bestelldatum als Erstes in den Primärschlüssel und erzeugen dann mithilfe der InnoDB-Storage-Engine Daten-Cluster anhand des Datums. Indem Sie Bereiche aus Daten partitionieren, können Sie Cluster auf einer höheren Ebene anlegen. Dies ist die grundlegende Tabellendefinition ohne eine Angabe der Partitionierung: CREATE TABLE sales_by_day ( day DATE NOT NULL, product INT NOT NULL, sales DECIMAL(10, 2) NOT NULL, returns DECIMAL(10, 2) NOT NULL, PRIMARY KEY(day, product) ) ENGINE=InnoDB;
Genau wie die Partitionierung nach dem Tag ist die Partitionierung nach dem Jahr üblich für den Umgang mit datumsbasierten Daten. Die Funktionen YEAR( ) und TO_DAYS( ) eignen sich in diesem Fall gut als Partitionsfunktionen. Im Allgemeinen hat eine gute Funktion für die Bereichspartitionierung eine lineare Beziehung zu den Werten, nach denen partitioniert werden soll. Auf diese Funktionen trifft diese Beschreibung zu. Partitionieren wir nach dem Jahr: mysql> ALTER TABLE sales_by_day -> PARTITION BY RANGE(YEAR(day)) ( -> PARTITION p_2006 VALUES LESS THAN (2007), -> PARTITION p_2007 VALUES LESS THAN (2008), -> PARTITION p_2008 VALUES LESS THAN (2009), -> PARTITION p_catchall VALUES LESS THAN MAXVALUE );
Wenn wir nun Zeilen einfügen, werden diese in der passenden Partition gespeichert, je nach dem Wert der day-Spalte: mysql> INSERT INTO sales_by_day(day, product, sales, returns) VALUES -> ('2007-01-15', 19, 50.00, 52.00), -> ('2008-09-23', 11, 41.00, 42.00);
Wir verwenden diese Daten gleich noch in einem Beispiel. Bevor wir jedoch fortfahren, wollen wir darauf hinweisen, dass es hier eine wichtige Beschränkung gibt: Werden später noch mehr Jahre hinzugefügt, wird es notwendig, die Tabelle zu verändern, was bei einer großen Tabelle sehr teuer ist (wovon wir jetzt einmal ausgehen, da wir sonst keine Partitionen benutzen würden). Vielleicht sollten Sie einfach vorpreschen und mehr Jahre definieren, als Sie möglicherweise brauchen werden. Auch wenn Sie sie noch lange nicht benutzen, wird dadurch die Performance nicht wesentlich beeinflusst. Eine weitere gebräuchliche Anwendung für partitionierte Tabellen ist die Verteilung der Zeilen in einer großen Tabelle. Nehmen Sie z.B. an, dass Sie eine große Anzahl von
280 | Kapitel 5: Erweiterte MySQL-Funktionen
Abfragen an einer riesigen Tabelle durchführen. Falls Sie wollen, dass unterschiedliche physische Festplatten die Daten bereitstellen, während mehrere Abfragen an der Tabelle ausgeführt werden, könnten Sie veranlassen, dass MySQL die Zeilen über die Festplatten verteilt. In diesem Fall müssen Sie sich keine Gedanken darüber machen, verwandte Daten dicht beisammenzuhalten, sondern wollen die Daten lediglich gleichmäßig verteilen, ohne darüber nachdenken zu müssen. Folgendes sorgt dafür, dass MySQL die Zeilen um den Betrag des Primärschlüssels verteilt. Dies ist sehr gut geeignet, um Daten gleichförmig über die Partitionen zu verteilen: mysql> ALTER TABLE mydb.very_big_table -> PARTITION BY KEY() ( -> PARTITION p0 DATA DIRECTORY='/data/mydb/big_table_p0/', -> PARTITION p1 DATA DIRECTORY='/data/mydb/big_table_p1/');
Sie können das gleiche Ziel auch auf andere Weise mit einem RAID-Controller erreichen. Das kann manchmal besser sein: weil diese Methode in Hardware implementiert ist, sind die Einzelheiten ihrer Funktionsweise verborgen, so dass die Komplexität Ihres Schemas und Ihrer Abfragen nicht unnütz vergrößert wird. Sie bietet möglicherweise auch eine bessere, gleichartigere Performance, falls Ihr einziges Ziel darin besteht, Ihre Daten physisch zu verteilen.
Beschränkungen partitionierter Tabellen Partitionierte Tabellen sind keine »Wunderwaffe«. Hier sind einige der Beschränkungen der aktuellen Implementierung: • Momentan müssen alle Partitionen die gleiche Storage-Engine benutzen. Sie können z.B. nicht nur einige Partitionen komprimieren, wie es bei den Merge-Tabellen möglich ist, bei denen Sie auch nur einige der zugrunde liegenden Tabellen komprimieren können. • Jeder eindeutige Index in einer partitionierten Tabelle muss die Spalten enthalten, auf die sich die Partitionsfunktion bezieht. Deshalb vermeiden viele als Anleitung dienende Beispiele die Verwendung eines Primärschlüssels. Es ist zwar bei Data Warehouses üblich, dass sie Tabellen ohne Primärschlüssel oder eindeutige Indizes enthalten, bei OLTP-Systemen ist das allerdings weniger gebräuchlich. Daraus folgt, dass Sie bei der Wahl der passenden Partitionierung Ihrer Daten wahrscheinlich stärker eingeschränkt sind, als Sie zunächst vermuten würden. • Obwohl MySQL während einer Abfrage nicht unbedingt auf alle Partitionen in einer partitionierten Tabelle zugreifen muss, werden alle Partitionen gesperrt. • Es gibt einige Einschränkungen hinsichtlich der Funktionen und Ausdrücke, die Sie in einer Partitionierungsfunktion benutzen können. • Manche Storage-Engines funktionieren nicht mit Partitionierung. • Fremdschlüssel funktionieren nicht. • Sie können LOAD INDEX INTO CACHE nicht benutzen.
Merge-Tabellen und Partitionierung | 281
Es gibt natürlich noch weitere Einschränkungen (zumindest zum Zeitpunkt der Entstehung dieses Buches, als MySQL 5.1 noch nicht allgemein verfügbar war). Tatsächlich sind partitionierte Tabellen in mancher Hinsicht weniger flexibel als Merge-Tabellen. Zum Beispiel können Sie nicht einmal eben schnell zu einer partitionierten Tabelle Stück für Stück einen Index hinzufügen: Das ALTER sperrt die gesamte Tabelle und baut sie neu auf. Merge-Tabellen bieten Ihnen da mehr Möglichkeiten, wie den Index zu einer zugrundeliegenden Tabelle auf einmal hinzuzufügen. Sie können auch nicht einfach eine Partition allein sichern oder wiederherstellen, was bei den einer Merge-Tabelle zugrunde liegenden Tabellen ohne Weiteres geht. Ob eine Tabelle von der Partitionierung profitiert, hängt von vielen Faktoren ab. Sie müssen Ihre eigenen Anwendungen mit Benchmarks testen, um festzustellen, ob Partitionierung eine gute Lösung für Sie darstellt.
Abfragen an partitionierte Tabellen optimieren Die Partitionierung bringt neue Möglichkeiten mit sich, um Abfragen zu optimieren (und entsprechende Fallstricke zu umgehen). Der Optimierer kann die Partitionierungsfunktion benutzen, um Partitionen zu leeren oder sie ganz aus einer Abfrage zu entfernen. Er tut dies, indem er schließt, dass die gewünschten Zeilen nur in bestimmten Partitionen zu finden sind. Das Kürzen sorgt also dafür, dass die Abfragen auf viel weniger Daten zugreifen müssen, als es ansonsten nötig wäre (im besten Fall). Es ist sehr wichtig, den partitionierten Schlüssel in der WHERE-Klausel anzugeben, selbst wenn er ansonsten redundant ist, damit der Optimierer die unnötigen Partitionen leeren kann. Wenn Sie dies tun, muss die Abfrageausführungs-Engine, genau wie bei MergeTabellen, auf alle Partitionen in der Tabelle zugreifen. Das kann bei großen Tabellen außerordentlich langsam verlaufen. Mithilfe von EXPLAIN PARTITIONS können Sie feststellen, ob der Optimierer Partitionen leert. Kehren wir noch einmal zu unseren Beispieldaten zurück: mysql> EXPLAIN PARTITIONS SELECT * FROM sales_by_day\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: sales_by_day partitions: p_2006,p_2007,p_2008 type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 3 Extra:
Wie Sie sehen können, greift die Abfrage auf alle Partitionen zu. Schauen Sie sich den Unterschied an, wenn wir zur WHERE-Klausel eine Bedingung hinzufügen:
282 | Kapitel 5: Erweiterte MySQL-Funktionen
mysql> EXPLAIN PARTITIONS SELECT * FROM sales_by_day WHERE day > '2007-01-01'\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: sales_by_day partitions: p_2007,p_2008
Der Optimierer ist ziemlich gut im Entleeren. Er kann sogar Bereiche in Listen aus diskreten Werten umwandeln und dann die einzelnen Elemente in der Liste kürzen. Allerdings ist er nicht allwissend. So ist z.B. die folgende WHERE-Klausel theoretisch kürzbar, dennoch kann MySQL sie nicht leeren: mysql> EXPLAIN PARTITIONS SELECT * FROM sales_by_day WHERE YEAR(day) = 2007\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: sales_by_day partitions: p_2006,p_2007,p_2008
Momentan kann MySQL nur in Vergleichen mit den Spalten der Partitionierungsfunktion kürzen bzw. leeren. Beim Ergebnis eines Ausdrucks ist das dagegen nicht möglich, selbst wenn der Ausdruck identisch mit der Partitionierungsfunktion ist. Sie können die Abfrage jedoch in eine äquivalente Form umwandeln: mysql> EXPLAIN PARTITIONS SELECT * FROM sales_by_day -> WHERE day BETWEEN '2007-01-01' AND '2007-12-31'\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: sales_by_day partitions: p_2007
Da die WHERE-Klausel sich nun direkt auf die Partitionierungsspalte bezieht und nicht auf einen Ausdruck, kann der Optimierer seine vorteilhaften Kürzungen vornehmen. Der Optimierer ist auch klug genug, um die Partitionen während der Abfrageverarbeitung zu leeren. Falls z.B. eine partitionierte Tabelle die zweite Tabelle in einem Join ist und die Join-Bedingung der partitionierte Schlüssel ist, sucht MySQL nur in der relevanten Partition bzw. in den relevanten Partitionen nach passenden Zeilen. Das ist ein wichtiger Unterschied zu den Merge-Tabellen, die bei diesem Szenario immer alle zugrunde liegenden Tabellen abfragen.
Verteilte (XA-) Transaktionen Während Storage-Engine-Transaktionen innerhalb der Storage-Engine ACID-Eigenschaften realisieren, ist eine verteilte (XA-) Transaktion eine Transaktion auf höherer Ebene, die einige ACID-Eigenschaften außerhalb der Storage-Engine – und sogar außerhalb der Datenbank – mit einem zweiphasigen Commit erweitern kann. MySQL bietet ab Version 5.0 teilweise Unterstützung für XA-Transaktionen.
Verteilte (XA-) Transaktionen | 283
Eine XA-Transaktion erfordert einen Transaktionskoordinator, der alle Teilnehmer auffordert, sich auf das Commit vorzubereiten (Phase eins). Wenn der Koordinator von allen Teilnehmern ein »Fertig« empfängt, weist er sie an, fortzufahren und das Commit auszuführen. Das ist Phase zwei. MySQL kann in XA-Transaktionen als Teilnehmer auftreten, nicht jedoch als Koordinator. Es gibt genau genommen zwei Arten von XA-Transaktionen in MySQL. Der MySQL-Server kann an einer extern verwalteten verteilten Transaktion teilnehmen, er benutzt XA aber auch intern, um Storage-Engines und Binär-Logging zu koordinieren.
Interne XA-Transaktionen Die Ursache dafür, dass MySQL intern Xa-Transaktionen verwendet, ist die architektonische Trennung zwischen dem Server und den Storage-Engines. Storage-Engines sind völlig unabhängig voneinander und nehmen einander nicht wahr, so dass jede Engineübergreifende Transaktion von Natur aus verteilt ist und eine dritte Partei erfordert, um sie zu koordinieren. Diese dritte Partei ist der MySQL-Server. Gäbe es keine XA-Transaktionen, müssten z.B. bei jedem Engine-übergreifenden Transaktions-Commit nacheinander alle beteiligten Storage-Engines aufgefordert werden, ihre Bestätigung abzugeben. Dies bringt die Gefahr eines Absturzes mit sich, nachdem eine Engine ihr Commit abgegeben hat, aber bevor die anderen Engines so weit waren, was den Transaktionsregeln zuwiderlaufen würde. (Erinnern Sie sich: Transaktionen sollen als Alles-oder-NichtsOperationen agieren.) Wenn Sie das Binärlog als »Storage-Engine« für Log-Ereignisse betrachten, können Sie feststellen, weshalb XA-Transaktionen auch dann notwendig sind, wenn nur eine einzige transaktionsfähige Engine beteiligt ist. Das Synchronisieren eines Storage-Engine-Commits mit dem »Commit« eines Ereignisses am Binärlog ist eine verteilte Transaktion, weil der Server – und nicht die Storage-Engine – das Binärlog bedient. Momentan schafft XA ein Performance-Dilemma. Es hat die InnoDB-Unterstützung für das Gruppen-Commit (eine Technik, die mehrere Transaktionen mit einer einzigen Ein/Ausgabe-Operation bestätigen kann) seit MySQL 5.0 aufgehoben, so dass es viel mehr fsync( )-Aufrufe verursacht, als es eigentlich sollte. Es sorgt außerdem dafür, dass jede Transaktion eine Binärlog-Synchronisation erfordert, wenn Binärlogs aktiviert sind, und verlangt zwei Log-Entleerungen pro Commit statt nur einer. Falls Sie mit anderen Worten wollen, dass das Binärlog sicher mit Ihren Transaktionen synchronisiert wird, dann erfordert jede Transaktion wenigstens drei fsync( )-Aufrufe. Die einzige Möglichkeit, dies zu vermeiden, besteht darin, das Binärlog zu deaktivieren und innodb_support_xa auf 0 zu setzen. Diese Einstellungen sind inkompatibel mit der Replikation. Replikation erfordert BinärLogging und XA-Unterstützung, und darüber hinaus müssen Sie – um so sicher wie möglich zu sein – sync_binlog auf 1 setzen, damit die Storage-Engine und das Binärlog synchronisiert werden. (Die XA-Unterstützung ist ansonsten wertlos, da das Binärlog möglicherweise nicht auf Festplatte »bestätigt« wird.) Das ist einer der Gründe, weshalb 284 | Kapitel 5: Erweiterte MySQL-Funktionen
wir Ihnen dringend empfehlen, einen RAID-Controller mit einem batteriegesicherten Schreib-Cache zu benutzen: Der Cache kann die zusätzlichen fsync( )-Aufrufe beschleunigen und die Leistung wiederherstellen. Im nächsten Kapitel geht es genauer darum, wie man Transaktions- und Binär-Logging konfiguriert.
Externe XA-Transaktionen MySQL kann an extern verteilten Transaktionen zwar teilnehmen, ist aber nicht in der Lage, sie zu verwalten. Es bietet keine Unterstützung für die vollständige XA-Spezifikation. Zum Beispiel erlaubt die XA-Spezifikation, dass Verbindungen in einer einzigen Transaktion zusammengeführt werden, was mit MySQL momentan jedoch nicht möglich ist. Externe XA-Transaktionen sind sogar noch teurer als interne, da sie eine zusätzliche Latenz aufweisen sowie eine höhere Wahrscheinlichkeit mit sich bringen, dass einer der Teilnehmer ausfällt. Die Verwendung von XA über ein WAN oder sogar über das Internet ist aufgrund der unvorhersehbaren Netzwerkleistung eine verbreitete Falle. Es ist im Allgemeinen am besten, XA-Transaktionen zu vermeiden, wenn es eine unvorhersehbare Komponente gibt, wie etwa ein langsames Netzwerk oder einen Benutzer, der lange nicht den »Sichern«-Button anklickt. Alles, was ein Commit verzögert, ist mit hohen Kosten verbunden, weil es nicht nur in einem System, sondern potenziell in vielen Systemen Verzögerungen hervorruft. Es gibt jedoch andere Methoden, um leistungsstarke verteilte Transaktionen zu schaffen. So können Sie z.B. die Daten lokal einfügen und in eine Warteschlange einreihen und sie dann atomar, also einzeln in einer viel kleineren, schnelleren Transaktion verteilen. Sie können die Daten auch mithilfe der MySQL-Replikation von einem Platz zum anderen schicken. Wir haben festgestellt, das manche Anwendungen, die verteilte Transaktionen benutzen, diese eigentlich überhaupt nicht brauchen. Nichtsdestoweniger können XA-Transaktionen eine sinnvolle Methode darstellen, um Daten zwischen Servern zu synchronisieren. Diese Methode funktioniert gut, wenn Sie aus irgendeinem Grund keine Replikation einsetzen können oder wenn Updates nicht so entscheidend für die Performance sind.
Verteilte (XA-) Transaktionen | 285
KAPITEL 6
Die Servereinstellungen optimieren
Oft hört man die Frage: »Wie sieht die optimale Konfigurationsdatei für meinen Server mit 16 GByte RAM und 100 GByte Daten aus?« Um ehrlich zu sein, eine solche Datei gibt es nicht. Server benötigen je nach Hardware, Datengröße, den Arten von Abfragen, die auf ihnen ausgeführt werden, und den Anforderungen des Systems – Antwortzeit, Transaktionsdauer, Konsistenz usw. – sehr unterschiedliche Konfigurationen. Die Standardkonfiguration ist so gestaltet, dass sie nicht zu viele Ressourcen benutzt, da MySQL sehr vielseitig sein soll und wahrscheinlich nicht das einzige System ist, das auf dem Server läuft, auf dem es installiert ist. Diese Konfiguration verwendet standardmäßig genügend Ressourcen, um MySQL zu starten und einfache Abfragen mit wenigen Daten auszuführen. Sie müssen sie sicherlich anpassen, wenn Sie mehr als nur ein paar Megabyte an Daten haben. Sie können mit einer der Beispielkonfigurationsdateien beginnen, die in der MySQL-Serverdistribution enthalten sind, und sie nach Wunsch verändern. Erwarten Sie keine großen Leistungszuwächse von jeder kleinen Konfigurationsänderung. Abhängig von Ihrer Last können Sie die Leistung normalerweise zwei- oder dreifach steigern, indem Sie die passenden Werte für eine Handvoll Konfigurationseinstellungen wählen (welche Optionen genau diesen Unterschied ausmachen, hängt von einer Vielzahl von Faktoren ab). Danach erfolgen Verbesserungen schrittweise. Sie werden eine bestimmte Abfrage bemerken, die langsam läuft und die Sie verbessern, indem Sie eine oder zwei Einstellungen verändern, aber Sie werden normalerweise Ihre Serverleistung nicht um Größenordnungen steigern können. Um einen solchen Fortschritt zu erzielen, müssen Sie im Allgemeinen Ihr Schema, die Abfragen und die Architektur der Anwendungen überprüfen. Am Anfang dieses Kapitels zeigen wir Ihnen, wie die Konfigurationsoptionen von MySQL funktionieren und wie Sie sie ändern können. Anschließend erklären wir, wie MySQL Speicher benutzt und wie Sie seine Speicherverwendung optimieren. Dann behandeln wir detailliert die Ein-/Ausgabe und die Festplattenspeicherung. Es folgt ein Abschnitt über die lastbasierte Feineinstellung, mit deren Hilfe Sie MySQL so anpassen können, dass es am besten für Ihre Last funktioniert. Schließlich folgen noch einige Hinweise zum dynamischen Tuning von Variablen für bestimmte Abfragen, die eigene Einstellungen erfordern.
286 |
Ein Hinweis zur Terminologie: Da viele MySQL-Kommandozeilenoptionen bestimmten Servervariablen entsprechen, verwenden wir manchmal die Begriffe Option und Variable synonym.
Grundlagen der Konfiguration In diesem Abschnitt erhalten Sie einen Überblick darüber, wie Sie MySQL erfolgreich konfigurieren. Zuerst erläutern wir, wie die MySQL-Konfiguration tatsächlich funktioniert, dann zeigen wir einige optimale Verfahren. MySQL ist im Allgemeinen ziemlich nachsichtig, was seine Konfiguration betrifft. Sie sparen jedoch eine Menge Arbeit und Zeit, wenn Sie diese Vorschläge befolgen. Zuerst müssen Sie wissen, woher MySQL seine Konfigurationsinformationen bezieht: von Kommandozeilenargumenten und Einstellungen in seiner Konfigurationsdatei. Auf Unix-artigen Systemen befindet sich die Konfigurationsdatei typischerweise unter /etc/my.cnf oder /etc/mysql/my.cnf. Wenn Sie die Startskripte Ihres Betriebssystems verwenden, dann bilden diese üblicherweise den einzigen Ort, an dem Sie Konfigurationseinstellungen angeben. Falls Sie MySQL – etwa im Rahmen einer Testinstallation – manuell starten, können Sie diese Werte auch auf der Kommandozeile angeben. Die meisten Variablen tragen die gleichen Namen wie ihre entsprechenden Kommandozeilenoptionen, es gibt aber auch einige Ausnahmen. Zum Beispiel setzt --memlock die locked_in_memory-Variable.
Alle Einstellungen, die Sie permanent verwenden wollen, sollten nicht auf der Kommandozeile angegeben, sondern in die globale Konfigurationsdatei gesetzt werden. Ansonsten riskieren Sie, den Server versehentlich ohne sie zu starten. Es bietet sich außerdem an, alle Konfigurationsdateien an einer einzigen Stelle aufzuheben, damit Sie sie leicht untersuchen können. Vergewissern Sie sich, wo sich die Konfigurationsdatei des Servers tatsächlich befindet! Wir haben Leute gesehen, die erfolglos versucht haben, einen Server mithilfe einer Datei zu verändern, die dieser überhaupt nicht gelesen hat, wie etwa /etc/my.cnf bei Debian GNU/Linux-Servern, die in /etc/mysql/my.cnf nach ihrer Konfiguration suchen. Manchmal befinden sich Dateien an mehreren Stellen, weil möglicherweise ein früherer Systemadministrator ebenfalls durcheinander war. Falls Sie nicht wissen, welche Dateien Ihr Server liest, dann fragen Sie ihn einfach: $ which mysqld /usr/sbin/mysqld $ /usr/sbin/mysqld --verbose --help | grep -A 1 'Default options' Default options are read from the following files in the given order: /etc/mysql/my.cnf ~/.my.cnf /usr/etc/my.cnf
Das gilt für typische Installationen, bei denen ein einziger Server auf einem Host läuft. Sie können kompliziertere Konfigurationen schaffen, es gibt dafür allerdings keine Standard-
Grundlagen der Konfiguration | 287
methode. Die MySQL-Serverdistribution enthält ein Programm namens mysqlmanager, das mehrere Instanzen aus einer einzigen Konfiguration mit separaten Abschnitten ausführen kann. (Dies ist ein Ersatz für das ältere Skript mysqld_multi.) Viele Betriebssystemdistributionen enthalten dieses Programm jedoch nicht oder benutzen es nicht in ihren Startskripten. Viele verwenden nicht einmal das mit MySQL gelieferte Startskript. Die Konfigurationsdatei ist in Abschnitte unterteilt, die jeweils mit einer Zeile beginnen, die den Namen des Abschnitts in eckigen Klammern enthält. Ein MySQL-Programm liest im Allgemeinen den Abschnitt, der den gleichen Namen trägt wie das Programm. Viele Clientprogramme lesen außerdem den Abschnitt client, in dem Sie gebräuchliche Einstellungen ablegen können. Der Server liest normalerweise den Abschnitt mysqld. Achten Sie darauf, die Einstellungen in den richtigen Abschnitt der Datei zu legen, da sie sonst keine Wirkung haben.
Syntax, Geltungsbereich und Dynamismus Konfigurationseinstellungen werden kleingeschrieben, einzelne Wörter werden durch Unterstriche oder Bindestriche voneinander getrennt. Folgende Einstellungen sind äquivalent. Ihnen können beide Formen auf Kommandozeilen und in Konfigurationsdateien begegnen: /usr/sbin/mysqld --auto-increment-offset=5 /usr/sbin/mysqld --auto_increment_offset=5
Wir empfehlen Ihnen, sich für einen Stil zu entscheiden und diesen dann konsistent zu benutzen. Das erleichtert es Ihnen, in Ihren Dateien nach Einstellungen zu suchen. Konfigurationseinstellungen können mehrere Geltungsbereiche aufweisen. Manche Einstellungen gelten serverweit (globaler Geltungsbereich), andere sind bei jeder Verbindung anders (Geltungsbereich ist die Sitzung), wieder andere sind objektbezogen. Viele für eine Sitzung geltende Variablen haben globale Gegenstücke, die Sie sich als Standardwerte vorstellen können. Wenn Sie die Sitzungsvariable ändern, dann beeinflusst das nur die Verbindung, in der Sie sie geändert haben. Die Änderungen gehen verloren, wenn die Verbindung geschlossen wird. Hier sind einige Beispiele für die vielen Verhaltensweisen, die Sie beachten sollten: • Die Variable query_cache_size gilt global. • Die Variable sort_buffer_size besitzt einen globalen Standardwert, Sie können sie aber auch pro Sitzung einstellen. • Die Variable join_buffer_size hat einen globalen Standardwert und kann pro Sitzung eingestellt werden, allerdings kann eine einzelne Abfrage, die mehrere Tabellen in einem Join zusammenführt, einen Join-Puffer pro Join reservieren, so dass es mehrere Join-Puffer pro Abfrage geben kann. Sie können Variablen nicht nur in der Konfigurationsdatei einstellen, sondern viele von ihnen (aber nicht alle) ändern, während der Server läuft. MySQL bezeichnet diese als
288 | Kapitel 6: Die Servereinstellungen optimieren
dynamische Konfigurationsvariablen. Die folgenden Anweisungen zeigen unterschiedliche Methoden, um die Sitzungs- und die globalen Werte von sort_buffer_size dynamisch zu ändern: SET sort_buffer_size SET GLOBAL sort_buffer_size SET @@sort_buffer_size SET @@session.sort_buffer_size SET @@global.sort_buffer_size
= = := := :=
<Wert>; <Wert>; <Wert>; <Wert>; <Wert>;
Wenn Sie Variablen dynamisch einstellen, dann sollten Sie sich bewusst sein, dass diese Einstellungen verloren gehen, wenn MySQL beendet wird. Falls Sie die Einstellungen behalten wollen, müssen Sie auch Ihre Konfigurationsdatei anpassen. Wenn Sie den globalen Wert einer Variablen einstellen, während der Server läuft, werden die Werte für die aktuelle Sitzung und alle weiteren bereits existierenden Sitzungen nicht beeinflusst. Das liegt daran, dass die Sitzungswerte aus dem globalen Wert initialisiert werden, wenn die Verbindungen aufgebaut werden. Sie sollten nach jeder Änderung die Ausgabe von SHOW GLOBAL VARIABLES untersuchen, um sicherzustellen, dass sie die gewünschte Wirkung hatte. Variablen verwenden unterschiedliche Einheiten. Sie müssen für jede Variable die richtige Einheit kennen. So gibt z.B. die Variable table_cache die Anzahl der Tabellen an, die im Cache abgelegt werden können, und nicht die Größe des Tabellen-Cache in Byte. Die Variable key_buffer_size wird in Byte angegeben, während andere Variablen in Anzahl der Seiten oder in Prozent festgelegt werden. Viele Variablen können mit einem Suffix angegeben werden, wie z.B. 1M für ein Megabyte. Das funktioniert allerdings nur in der Konfigurationsdatei oder als Kommandozeilenargument. Wenn Sie den SQL-Befehl SET benutzen, müssen Sie den tatsächlichen Wert 1048576 oder einen Ausdruck wie 1024 * 1024 benutzen. Ausdrücke können Sie wiederum nicht in Konfigurationsdateien verwenden. Es gibt außerdem einen besonderen Wert, den Sie Variablen mit dem SET-Befehl zuweisen können: das Schlüsselwort DEFAULT. Wenn Sie diesen Wert einer sitzungsweit geltenden Variablen zuweisen, dann wird diese Variable auf den entsprechenden globalen Wert gesetzt; weisen Sie ihn einer global geltenden Variablen zu, wird die Variable auf den bei der Kompilierung festgelegten Standardwert gesetzt (nicht auf den Wert, der in der Konfigurationsdatei angegeben wurde). Das bietet sich an, wenn Sie sitzungsweit geltende Variablen wieder auf die Werte zurücksetzen wollen, die sie beim Öffnen der Verbindung hatten. Wir raten Ihnen, dies nicht für globale Variablen einzusetzen, da Sie damit wahrscheinlich nicht den gewünschten Effekt erzielen – d.h., dass die Werte nicht auf den Wert beim Serverstart zurückgesetzt werden.
Nebenwirkungen beim Einstellen von Variablen Das dynamische Einstellen von Variablen kann unerwartete Nebenwirkungen haben, etwa das Entfernen von schmutzigen Blöcken aus den Puffern. Seien Sie vorsichtig mit
Grundlagen der Konfiguration | 289
Einstellungen, die Sie online ändern, da diese dem Server unter Umständen eine Menge Arbeit machen. Manchmal lässt der Name einer Variablen Rückschlüsse auf ihr Verhalten zu. So macht z.B. max_heap_table_size genau das, was der Name besagt: Sie gibt die maximale Größe an, auf die implizite, im Speicher befindliche temporäre Tabellen anwachsen dürfen. Allerdings sind die Namenskonventionen nicht völlig konsistent, so dass Ihnen ein Blick auf den Namen nicht immer unbedingt verrät, was die Variable tut. Wir wollen uns nun einige wichtige Variablen anschauen und feststellen, welche Wirkungen es hat, wenn man sie dynamisch ändert: key_buffer_size
Durch das Einstellen dieser Variablen wird der gewünschte Platz für den Schlüsselpuffer (oder Schlüssel-Cache) gleich auf einmal reserviert. Allerdings stellt das Betriebssystem den Speicher erst dann zur Verfügung, wenn er tatsächlich benötigt wird. Zum Beispiel bedeutet das Einstellen der Schlüsselpuffergröße auf ein Gigabyte nicht, dass der Server auf der Stelle veranlasst wird, tatsächlich ein Gigabyte an Speicher dafür zu übergeben. (Im nächsten Kapitel erfahren Sie, wie Sie die Speicherbenutzung des Servers überwachen können.) MySQL erlaubt es Ihnen, mehrere Schlüssel-Caches zu erzeugen, wie wir später in diesem Kapitel erläutern. Wenn Sie diese Variable für einen nicht standardgemäßen Schlüssel-Cache auf 0 setzen, verschiebt MySQL alle Indizes aus dem angegebenen Cache in den Standard-Cache und löscht den angegebenen Cache, wenn er nicht mehr benutzt wird. Setzen Sie diese Variable für einen nicht existierenden Cache, dann wird dieser erzeugt. Wenn Sie diese Variable für einen existierenden Cache auf einen Wert ungleich null setzen, dann wird der Speicher des angegebenen Cache geleert. Technisch gesehen, handelt es sich hier um eine Online-Operation, allerdings werden alle Operationen blockiert, die versuchen, auf den Cache zuzugreifen, während er geleert wird. table_cache_size
Das Einstellen dieser Variablen hat keine unmittelbare Wirkung – diese wird verzögert, bis ein Thread das nächste Mal eine Tabelle öffnet. In diesem Fall überprüft MySQL den Wert der Variablen. Ist der Wert größer als die Anzahl der Tabellen im Cache, kann der Thread die neu geöffnete Tabelle in den Cache einfügen. Ist der Wert kleiner als die Anzahl der Tabellen im Cache, löscht MySQL unbenutzte Tabellen aus dem Cache. thread_cache_size
Das Setzen dieser Variablen hat keine unmittelbare Wirkung – diese wird verzögert, bis das nächste Mal eine Verbindung geschlossen wird. Zu diesem Zeitpunkt überprüft MySQL, ob im Cache Platz ist, um den Thread zu speichern. Ist dies der Fall, speichert es den Thread für eine künftige Wiederverwendung durch eine andere Verbindung im Cache. Ist es nicht der Fall, wird der Thread nicht gespeichert, sondern beendet. Hier wird die Anzahl der Threads im Cache und daher die Menge an
290 | Kapitel 6: Die Servereinstellungen optimieren
Speicher, die der Thread-Cache verwendet, nicht sofort verkleinert; sie verkleinern sich nur, wenn eine neue Verbindung einen Thread aus dem Cache entfernt, um ihn zu benutzen. (MySQL fügt nur dann Threads in den Cache ein, wenn Verbindungen geschlossen werden, und entfernt sie nur dann aus dem Cache, wenn neue Verbindungen erzeugt werden.) query_cache_size
MySQL reserviert und initialisiert die angegebene Speichermenge für den AbfrageCache auf einmal beim Serverstart. Wenn Sie diese Variable aktualisieren (sogar, wenn Sie sie auf ihren aktuellen Wert setzen), löscht MySQL sofort alle im Cache gespeicherten Abfragen, ändert die Größe des Cache auf den angegebenen Wert und reinitialisiert den Speicher des Cache. read_buffer_size
MySQL reserviert erst dann Speicher für diesen Puffer, wenn eine Abfrage ihn tatsächlich braucht, allerdings wird in diesem Fall sofort der komplette hier angegebene Speicher belegt. read_rnd_buffer_size
MySQL reserviert erst dann Speicher für diesen Puffer, wenn eine Abfrage ihn tatsächlich braucht; in diesem Fall wird nur so viel Speicher reserviert, wie nötig ist. (Der Name max_read_rnd_buffer_size würde diese Variable genauer beschreiben.) sort_buffer_size
MySQL reserviert erst dann Speicher für diesen Puffer, wenn eine Abfrage eine Sortierung durchführen muss. In diesem Fall belegt MySQL allerdings sofort den kompletten Speicher, ob nun die volle Größe benötigt wird oder nicht. Wir erläutern später noch genauer, was diese Variablen tun. Hier wollten wir Ihnen einfach nur zeigen, welches Verhalten Sie zu erwarten haben, wenn Sie diese wichtigen Variablen ändern.
Der Einstieg Seien Sie vorsichtig, wenn Sie Variablen setzen. Mehr ist nicht immer besser, und wenn Sie die Variablen zu hoch einstellen, können Sie sich leicht Probleme einhandeln: Ihnen geht der Speicher aus, Ihr Server muss deshalb Daten auf die Platte auslagern, oder sein Adressraum wird knapp. Wir empfehlen Ihnen, eine Benchmark-Suite zu entwickeln, bevor Sie mit der Feineinstellung Ihres Servers beginnen. (Benchmarking erklären wir in Kapitel 2.) Um die Konfiguration Ihres Servers zu optimieren, brauchen Sie eine Benchmark-Suite, die Ihre Gesamtlast darstellt und Grenzfälle einschließt, wie etwa sehr große und komplexe Abfragen. Wenn Sie eine bestimmte Problemstelle identifiziert haben – wie etwa eine Abfrage, die nur langsam läuft – können Sie auch versuchen, für diesen Fall zu optimieren. Allerdings laufen Sie dann Gefahr, unbemerkt andere Abfragen negativ zu beeinflussen.
Grundlagen der Konfiguration | 291
Sie sollten immer ein Überwachungssystem laufen lassen, um zu messen, ob eine Änderung die Gesamtleistung Ihres Servers im tatsächlichen Betrieb verbessert oder beeinträchtigt. Benchmarks reichen nicht, weil sie nicht umfassend genug sind. Wenn Sie die Gesamtleistung Ihres Servers nicht messen, beeinträchtigen Sie möglicherweise unabsichtlich die Leistung. Uns sind viele Fälle bekannt, in denen jemand die Konfiguration eines Servers geändert hat und der Meinung war, dass er damit die Leistung steigern könnte, während die Leistung des Servers in Wirklichkeit aufgrund einer anderen Last zu einem anderen Zeitpunkt des Tages oder eines anderen Wochentages insgesamt sank. Wir befassen uns in Kapitel 14 mit einigen Überwachungssystemen. Am besten ist es, wenn Sie nur eine oder zwei Variablen ein wenig ändern und nach jeder Änderung die Benchmark-Tests durchführen. Manchmal werden die Ergebnisse Sie überraschen: Sie erhöhen eine Variable ein wenig und stellen eine Verbesserung fest, Sie erhöhen sie weiter, und plötzlich bemerken Sie einen starken Einbruch der Leistung. Wenn die Performance nach einer Änderung leidet, haben Sie möglicherweise eine Ressource zu stark in Anspruch genommen, haben z.B. zu viel Speicher für einen Puffer belegt, der häufig reserviert und wieder freigegeben wird. Vielleicht ist es auch zu einer Fehlanpassung zwischen MySQL und Ihrem Betriebssystem oder der Hardware gekommen. Wir haben z.B. festgestellt, dass der optimale sort_buffer_size-Wert davon beeinflusst werden könnte, wie der CPU-Cache arbeitet, und dass der read_buffer_size-Wert daran angepasst werden muss, wie das Read-Ahead des Servers und das allgemeine Ein-/Ausgabe-Subsystem konfiguriert sind. Größer ist nicht immer besser. Manche Variablen sind auch von anderen abhängig, was Sie erst durch Erfahrung und mit zunehmendem Wissen über die Architektur des Systems lernen. So hängt z.B. der beste innodb_log_ file_size-Wert von innodb_buffer_pool_size ab. Wenn Sie sich Notizen machen, etwa mithilfe von Kommentaren in der Konfigurationsdatei, ersparen Sie sich (und Ihren Nachfolgern) mit Sicherheit eine Menge Arbeit. Noch besser ist es, wenn Sie die Konfigurationsdatei einer Versionskontrolle unterstellen. Das ist sowieso eine gute Vorgehensweise, da Sie auf diese Weise Änderungen widerrufen können. Um die Komplexität beim Verwalten vieler Konfigurationsdateien zu verringern, erzeugen Sie einfach einen symbolischen Link von der Konfigurationsdatei zum zentralen Versionskontroll-Repository. Mehr zu diesem Thema erfahren Sie in einem guten Buch über die Systemadministration. Bevor Sie damit beginnen, Ihre Konfiguration zu verfeinern, sollten Sie an Ihren Abfragen und Ihrem Schema arbeiten, um wenigstens die offensichtlichsten Optimierungen durchzuführen, wie etwa das Anlegen von Indizes. Wenn Sie stark an der Konfiguration herumbasteln und dann Ihre Abfragen oder Ihr Schema ändern, müssen Sie möglicherweise noch einmal an die Konfiguration Hand anlegen. Denken Sie daran, dass das Feineinstellen ein laufender, iterativer Prozess ist. Wenn Ihre Hardware, die Last und die Daten nicht völlig statisch sind, müssen Sie immer wieder an Ihrer Konfiguration arbeiten. Das bedeutet, dass Sie nicht das letzte Quäntchen Leistung aus Ihrem Server herausquetschen müssen. Vermutlich wäre der Nutzen, den Sie aus dem dafür erforderlichen, immensen Zeitaufwand ziehen würden, sowieso relativ gering. Wir empfehlen Ihnen, Ihre Konfigu-
292 | Kapitel 6: Die Servereinstellungen optimieren
ration zu verfeinern, bis sie »gut genug« ist, und sie dann so zu lassen, bis Sie irgendwann Grund zu der Annahme haben, dass doch noch (oder wieder?) eine deutliche Leistungssteigerung möglich ist. Auch wenn Sie Ihr Schema oder Ihre Abfragen ändern, sollten Sie sich die Konfiguration noch einmal vornehmen. Wir entwickeln im Allgemeinen Beispielkonfigurationsdateien für verschiedene Zwecke und benutzen sie als unsere eigenen Vorgaben, vor allem, wenn wir viele ähnliche Server in einer Installation verwalten. Doch wie wir bereits am Anfang dieses Kapitels warnend angemerkt haben, besitzen wir keine allumfassende »beste Konfigurationsdatei« für z.B. einen Vier-CPU-Server mit 16 GByte Speicher und 12 Festplatten. Sie müssen wirklich Ihre eigenen Konfigurationen entwickeln, weil sogar eine gute Ausgangsposition je nach Einsatz Ihres Servers stark variiert.
Allgemeines Tuning Sie können die Konfiguration als einen zweiteiligen Vorgang betrachten: Benutzen Sie einige der grundlegenden Fakten über Ihre Installation, um einen sinnvollen Ausgangspunkt zu schaffen, und modifizieren Sie diesen dann anhand der Details über Ihre Arbeitslast. Wahrscheinlich sollten Sie eines der Beispiele als Ausgangspunkt verwenden, die MySQL mitbringt. Beachten Sie bei der Wahl des passenden Musters Ihre Hardware. Wie viele Festplatten und CPUs haben Sie und wie viel Speicher? Die Beispiele tragen sinnvolle Namen wie my-huge.cnf, my-large.cnf und my-small.cnf, es sollte also klar sein, mit welchem Sie beginnen. Allerdings gelten die Beispieldateien nur für MyISAM-Tabellen. Wenn Sie eine andere Storage-Engine benutzen, müssen Sie eine eigene Konfiguration herstellen.
Die Speicherbenutzung anpassen Für eine gute Leistung ist es entscheidend, dass MySQL den Speicher richtig benutzt. Sie müssen die Speicherbenutzung von MySQL mit hoher Wahrscheinlichkeit an Ihre Anforderungen anpassen. Im Prinzip lässt sich die Speicherbenutzung von MySQL in zwei Kategorien einteilen: Speicher, den Sie kontrollieren können, und Speicher, bei dem Sie das nicht können. Sie können nicht kontrollieren, wie viel Speicher MySQL lediglich zum Ausführen des Servers, zum Parsen der Abfragen und zum Verwalten seiner internen Angelegenheiten verwendet, Sie haben aber eine Menge Kontrolle darüber, wie viel Speicher es für besondere Aufgaben einsetzt. Es ist nicht schwer, den Speicher, den Sie kontrollieren können, gut einzusetzen, verlangt aber, dass Sie wissen, was Sie konfigurieren. Sie können die Speicheranpassung schrittweise vornehmen: 1. Ermitteln Sie die absolute obere Grenze dessen, was MySQL an Speicher möglicher-
weise nutzen kann. 2. Stellen Sie fest, wie viel Speicher MySQL für seine verbindungsbezogenen Bedürf-
nisse benutzt, wie etwa Sortierpuffer und temporäre Tabellen. Allgemeines Tuning | 293
3. Stellen Sie fest, wie viel Speicher das Betriebssystem benötigt, um gut zu laufen.
Rechnen Sie Speicher für andere Programme hinzu, die auf der gleichen Maschine laufen, wie etwa regelmäßig ausgeführte Jobs. 4. Vorausgesetzt, das ist jetzt noch sinnvoll, verwenden Sie den Rest des Speichers für
die MySQL-Caches, wie etwa den InnoDB-Pufferpool. Wir werden diese Schritte in den folgenden Abschnitten durchgehen. Anschließend werfen wir einen ausführlicheren Blick auf die Anforderungen der verschiedenen MySQLCaches.
Wie viel Speicher kann MySQL benutzen? Es gibt auf jedem System eine strikte obere Grenze für den Speicher, der MySQL höchstens zur Verfügung gestellt werden kann. Der Ansatzpunkt ist die Menge des physisch vorhandenen Speichers. Wenn Ihr Server ihn nicht hat, kann MySQL ihn nicht benutzen. Sie müssen außerdem an die Grenzen des Betriebssystems oder der Architektur denken, wie z.B. an die Beschränkungen, die 32-Bit-Betriebssysteme in Bezug auf den Speicher auferlegen, den ein bestimmter Prozess ansprechen kann. Da MySQL in einem einzelnen Prozess mit mehreren Threads läuft, kann die Speichermenge, die es insgesamt benutzen kann, durch solche Beschränkungen stark begrenzt sein – z.B. begrenzen 32-Bit-LinuxKernel die Menge an Speicher, die ein Prozess adressieren kann, auf einen Wert, der typischerweise zwischen 2,5 und 2,7 GByte liegt. Es ist sehr gefährlich, wenn einem der Adressraum ausgeht, und kann zum Absturz von MySQL führen. Es gibt viele weitere betriebssystemspezifische Parameter und Eigenarten, die man in Betracht ziehen muss. Dazu gehören nicht nur die prozessweisen Beschränkungen, sondern auch Stack-Größen und andere Einstellungen. Die glibc-Bibliotheken des Systems können auch Beschränkungen pro einzelner Allozierung verhängen. So könnte es sein, dass Sie nicht in der Lage sind, innodb_buffer_pool größer als 2 GByte einzustellen, wenn das alles ist, was Ihre glibc-Bibliotheken in einer einzigen Allozierung unterstützen. Selbst auf 64-Bit-Servern gelten Beschränkungen. So sind z.B. viele der Puffer, die wir hier besprechen, wie etwa der Schlüsselpuffer, auf einem 64-Bit-Server auf 4 GByte beschränkt. Einige dieser Einschränkungen wurden in MySQL 5.1 aufgehoben, und künftig gibt es wahrscheinlich noch weitere Änderungen, weil man bei MySQL AB aktiv daran arbeitet, dass MySQL leistungsfähigere Hardware besser ausnutzen kann. Im MySQL-Handbuch sind die Maximalwerte der einzelnen Variablen dokumentiert.
Speicheranforderungen pro Verbindung MySQL braucht wenigstens ein bisschen Speicher, um eine Verbindung (Thread) offen zu halten. Auch zum Ausführen einer Abfrage benötigt es eine gewisse Grundmenge an Speicher. Sie müssen genügend Speicher für MySQL vorsehen, um Abfragen während Spitzenzeiten auszuführen, da die Abfragen ansonsten aufgrund des Speichermangels entweder schlecht laufen oder fehlschlagen.
294 | Kapitel 6: Die Servereinstellungen optimieren
Es ist sinnvoll zu wissen, wie viel Speicher MySQL in Spitzenzeiten benötigt, allerdings kann es vorkommen, dass einige Nutzungsmuster unerwarteterweise viel Speicher in Anspruch nehmen, was sich schwer vorhersagen lässt. Vorbereitete Anweisungen sind ein Beispiel dafür, weil Sie viele von ihnen auf einmal offen haben können. Ein weiteres Beispiel ist der InnoDB-Tabellen-Cache (mehr darüber später). Sie müssen nicht gleich ein Worst-Case-Szenario annehmen, wenn Sie versuchen, den Speicherverbrauch in Spitzenzeiten vorherzusagen. Falls Sie z.B. MySQL so konfigurieren, dass maximal 100 Verbindungen erlaubt sind, könnte es theoretisch möglich sein, gleichzeitig große Abfragen auf allen 100 Verbindungen auszuführen. In der Realität dagegen wird dieser Fall wohl nicht eintreten. Falls Sie z.B. myisam_sort_buffer_size auf 256M setzen, liegt der Verbrauch im schlimmsten Fall bei wenigstens 25 GByte, allerdings wird dieser Fall mit hoher Wahrscheinlichkeit nicht eintreten. Anstatt Worst-Case-Szenarien zu berechnen, besteht ein besserer Ansatz darin, Ihren Server unter einer echten Arbeitslast zu beobachten und zu ermitteln, wie viel Speicher er benutzt. Das können Sie feststellen, wenn Sie die Größe des virtuellen Speichers des Prozesses beobachten. Bei vielen Unix-artigen Systemen finden Sie diesen Wert in der VIRTSpalte in top oder unter VSZ in ps. Im nächsten Kapitel erfahren Sie mehr darüber, wie Sie die Speicherbenutzung überwachen.
Speicher für das Betriebssystem reservieren Genau wie für Abfragen müssen Sie auch für das Betriebssystem genügend Speicher reservieren, damit es seine Arbeit verrichten kann. Sie erkennen, dass das Betriebssystem genug Speicher hat, wenn es nicht aktiv virtuellen Speicher auf die Festplatte auslagert (Swapping). (In »Swapping« auf Seite 364 finden Sie mehr zu diesem Thema.) Sie sollten nicht mehr als ein oder zwei Gigabyte für das Betriebssystem reservieren müssen, auch nicht auf Maschinen mit viel Speicher. Fügen Sie eine Sicherheitsreserve hinzu, die Sie noch ein wenig erhöhen sollten, wenn Sie regelmäßig speicherintensive Jobs auf der Maschine ausführen (z.B. Backups). Fügen Sie keinen Speicher für die Caches des Betriebssystems hinzu, da diese sehr groß werden können. Im Allgemeinen verwendet das Betriebssystem übrig gebliebenen Speicher für diese Caches. Wir betrachten diese getrennt von den betriebssystemeigenen Anforderungen in den folgenden Abschnitten.
Speicher für Caches belegen Wenn der Server speziell für MySQL vorgesehen ist, steht jeder Speicher, den Sie nicht für das Betriebssystem oder für die Abfrageverarbeitung reservieren, für die Caches zur Verfügung. MySQL braucht mehr Speicher für Caches als für alles andere. Es benutzt Caches, um Festplattenzugriffe zu vermeiden, die um Größenordnungen langsamer sind als Zugriffe auf die Daten im Speicher. Das Betriebssystem kann im Namen von MySQL (besonders für MyISAM) Daten im Cache ablegen. Allerdings braucht MySQL für sich selbst schon eine Menge Speicher.
Allgemeines Tuning | 295
Im Folgenden sehen Sie die wichtigsten Caches, die Sie für die meisten Installationen berücksichtigen müssen: • die Betriebssystem-Caches für MyISAM-Daten • MyISAM-Schlüssel-Caches • den InnoDB-Pufferpool • den Abfrage-Cache Es gibt weitere Caches, die aber im Allgemeinen nicht so viel Speicher benutzen. Wir haben den Abfrage-Cache im vorangegangenen Kapitel ausführlich besprochen, so dass wir uns in den folgenden Abschnitten auf die Caches konzentrieren wollen, die MyISAM und InnoDB brauchen, um gut zu funktionieren. Es ist viel einfacher, einen Server zu verfeinern, wenn Sie nur eine Storage-Engine benutzen. Falls Sie nur mit MyISAM-Tabellen arbeiten, können Sie InnoDB komplett deaktivieren. Benutzen Sie dagegen nur InnoDB, müssen Sie nur minimale Ressourcen für MyISAM vorsehen (MySQL verwendet intern MyISAM-Tabellen für einige Operationen). Benutzen Sie hingegen eine Mischung aus Storage-Engines, dann ist es nicht leicht, das richtige Gleichgewicht zwischen ihnen zu finden. Der beste Ansatz, den wir gefunden haben, besteht darin, zuerst gezielte Vermutungen anzustellen und dann einen Benchmark-Test durchzuführen.
Der MyISAM-Schlüssel-Cache Die MyISAM-Schlüssel-Caches werden auch als Schlüssel-Puffer bezeichnet. Standardmäßig gibt es einen, Sie können aber auch mehrere davon anlegen. Im Gegensatz zu InnoDB und einigen anderen Storage-Engines legt MyISAM selbst nur Indizes im Cache ab, keine Daten (dies überlässt es dem Betriebssystem). Wenn Sie hauptsächlich MyISAM benutzen, sollten Sie für die Schlüssel-Caches nicht viel Speicher vorsehen. Viele der Ratschläge in diesem Abschnitt gehen davon aus, dass Sie nur MyISAM-Tabellen verwenden. Falls Sie einen Mix aus MyISAM und einer anderen Engine, wie etwa InnoDB, einsetzen, müssen Sie die Anforderungen beider Storage-Engines berücksichtigen.
Die wichtigste Option ist key_buffer_size. Sie sollten versuchen, deren Wert auf 25 % bis 50 % der Speichermenge einzustellen, die Sie für Caches reserviert haben. Der Rest steht für die Betriebssystem-Caches zur Verfügung, die das Betriebssystem normalerweise mit Daten aus den .MYD-Dateien von MyISAM füllt. MySQL 5.0 besitzt, ungeachtet der verwendeten Architektur, eine strenge obere Grenze von 4 GByte für diese Variable. MySQL 5.1 erlaubt größere Größen. Schauen Sie in die aktuelle Dokumentation für Ihre Version des Servers. Standardmäßig legt MyISAM alle Indizes im vorgegebenen Schlüsselpuffer ab, allerdings können Sie mehrere benannte Schlüsselpuffer erzeugen. So haben Sie die Möglichkeit,
296 | Kapitel 6: Die Servereinstellungen optimieren
mehr als 4 GByte Indizes auf einmal im Speicher zu behalten. Um Schlüsselpuffer mit den Namen key_buffer_1 und key_buffer_2 zu erzeugen, die jeweils 1 GByte groß sind, schreiben Sie Folgendes in die Konfigurationsdatei: key_buffer_1.key_buffer_size = 1G key_buffer_2.key_buffer_size = 1G
Jetzt gibt es drei Schlüsselpuffer: die beiden explizit mit diesen Zeilen erzeugten und den Standardpuffer. Mit dem Befehl CACHE INDEX ordnen Sie Tabellen zu Caches zu. Mit der folgenden SQL-Anweisung weisen Sie MySQL an, key_buffer_1 für die Indizes aus den Tabellen t1 und t2 zu benutzen: mysql> CACHE INDEX t1, t2 IN key_buffer_1;
Wenn MySQL nun Blöcke aus den Indizes in diesen Tabellen liest, speichert es die Blöcke in dem angegebenen Puffer. Sie können die Indizes der Tabellen sogar vorab in den Cache laden, und zwar mit dem Befehl LOAD INDEX: mysql> LOAD INDEX INTO CACHE t1, t2;
Sie können dieses SQL in eine Datei setzen, die ausgeführt wird, wenn MySQL startet. Der Dateiname muss in der Option init_file angegeben werden. Die Datei kann mehrere SQL-Befehle enthalten, die jeweils auf einer eigenen Zeile stehen (Kommentare sind nicht erlaubt). Alle Indizes, die Sie nicht explizit zu einem Schlüsselpuffer zuordnen, werden dem Standardpuffer zugewiesen, wenn MySQL das erste Mal auf die .MYI-Datei zugreifen muss. Sie können die Leistung und die Benutzung der Schlüsselpuffer mit Informationen aus SHOW STATUS und SHOW VARIABLES überwachen. Mit den folgenden Gleichungen berechnen
Sie die Trefferrate und den Prozentsatz des benutzten Puffers: Cache-Trefferrate 100 - ( (Key_reads * 100) / Key_read_requests )
Verwendeter Puffer in Prozent 100 - ( (Key_blocks_unused * key_cache_block_size) * 100 / key_buffer_size ) In Kapitel 14 untersuchen wir einige Werkzeuge, wie etwa innotop zur bequemeren Performance-Überwachung.
Es ist auch ganz gut, wenn man die Cache-Trefferrate kennt, allerdings kann diese Zahl auch irreführend sein. So sieht z.B. der Unterschied zwischen 99 % und 99,9 % klein aus, repräsentiert jedoch eine zehnfache Zunahme. Die Cache-Trefferrate ist auch anwendungsabhängig: Manche Anwendungen würden gut bei 95 % funktionieren, während andere ein-/ausgabegebunden bei 99,9 % liegen. Bei entsprechend bemessenen Caches könnten Sie sogar eine Trefferrate von 99,99 % erzielen. Die Anzahl der Cache-Misses, also der Cache-Fehler, pro Sekunde ist im Allgemeinen eher empirisch von Nutzen. Nehmen Sie einmal an, Sie haben eine Festplatte, die 100
Allgemeines Tuning | 297
wahlfreie Lesezugriffe pro Sekunde schafft. Fünf Misses pro Sekunde sorgen noch nicht dafür, dass Ihre Last ein-/ausgabegebunden ist, 80 Misses pro Sekunde verursachen dagegen wahrscheinlich Probleme. Mit der folgenden Gleichung können Sie diesen Wert berechnen: Key_reads / Uptime
Berechnen Sie die Anzahl der Cache-Fehler ansteigend über Intervalle von 10 bis 100 Sekunden, um eine Vorstellung von der aktuellen Leistung zu erhalten. Der folgende Befehl zeigt die zunehmenden Werte alle 10 Sekunden: $ mysqladmin extended-status -r -i 10 | grep Key_reads
Wenn Sie entscheiden, wie viel Speicher Sie für die Schlüssel-Caches reservieren, hilft es vermutlich zu wissen, wie viel Platz Ihre MyISAM-Indizes tatsächlich auf der Festplatte belegen. Sie müssen die Schlüssel-Puffer nicht größer machen als die Daten, die sie im Cache ablegen. Auf einem Unix-artigen System ermitteln Sie die Größe der Dateien, die die Indizes speichern, mit einem solchen Befehl: $ du -sch `find /path/to/mysql/data/directory/ -name "*.MYI"`
Denken Sie daran, dass MyISAM den Betriebssystem-Cache für die Datendateien benutzt, die oft größer sind als die Indizes. Es ist daher oft sinnvoll, für den Betriebssystem-Cache mehr Speicher bereitzustellen als für die Schlüssel-Caches. Und selbst wenn Sie keine MyISAM-Tabellen haben, müssen Sie daran denken, dass Sie noch key_buffer_ size auf eine kleine Menge Speicher setzen müssen, wie etwa 32M. Der MySQL-Server nutzt MyISAM-Tabellen manchmal für interne Zwecke, wie z.B. temporäre Tabellen für GROUP BY-Abfragen.
Die Größe des MyISAM-Schlüsselblocks Die Schlüsselblockgröße ist aufgrund der Art, wie sie MyISAM, den BetriebssystemCache und das Dateisystem zur Interaktion veranlasst, wichtig (besonders für schreibintensive Aufgaben). Wenn die Schlüsselblockgröße zu klein ausfällt, werden Sie möglicherweise Read-around Writes bemerken. Dabei handelt es sich um Schreibvorgänge, die das Betriebssystem nicht ausführen kann, ohne zuerst einige Daten von der Festplatte zu lesen. Und so kommt es zu einem Read-around Write (es wird angenommen, dass die Seitengröße des Betriebssystems 4 KByte beträgt, was typisch für die x86-Architektur ist, und dass ein Schlüsselblock 1 KByte groß ist): 1. MyISAM fordert einen 1 KByte großen Schlüsselblock von der Festplatte an. 2. Das Betriebssystem liest 4 KByte Daten von der Festplatte und speichert sie im
Cache, dann übergibt es die gewünschten 1 KByte Daten an MyISAM. 3. Das Betriebssystem verwirft die im Cache gespeicherten Daten zugunsten irgend-
welcher anderen Daten. 4. MyISAM modifiziert den 1 KByte großen Schlüsselblock und bittet das Betriebssys-
tem, ihn wieder zurück auf die Festplatte zu schreiben.
298 | Kapitel 6: Die Servereinstellungen optimieren
5. Das Betriebssystem liest die gleichen 4 KByte Daten von der Festplatte in den
Betriebssystem-Cache ein, modifiziert das 1 KByte, das MyISAM geändert hat, und schreibt die gesamten 4 KByte zurück auf die Festplatte. Das Read-around Write trat in Schritt 5 auf, als MyISAM das Betriebssystem gebeten hat, nur einen Teil einer 4-KByte-Seite zu schreiben. Hätte die Blockgröße von MyISAM derjenigen des Betriebssystems entsprochen, dann hätte das Lesen von der Festplatte in Schritt 5 vermieden werden können.1 Leider gab es bis MySQL 5.0 keine Möglichkeit, die Schlüsselblockgröße zu konfigurieren. Seit MySQL 5.1 dagegen können Sie Read-around Writes vermeiden, indem Sie die Schlüsselblockgröße von MyISAM genauso groß machen wie die des Betriebssystems. Die Variable myisam_block_size steuert die Schlüsselblockgröße. Sie können die Größe der einzelnen Schlüssel mit der Option KEY_BLOCK_SIZE in den Anweisungen CREATE TABLE oder CREATE INDEX angeben. Da aber alle Schlüssel in derselben Datei gespeichert werden, müssen tatsächlich alle von ihnen Blöcke haben, die so groß sind wie die des Betriebssystems oder größer, um Probleme mit der Anordnung zu vermeiden, die immer noch Readaround Writes verursachen könnten. (Falls z.B. ein Schlüssel 1-KByte-Blöcke hat und ein anderer 4-KByte-Blöcke, dann passen die 4-KByte-Blockgrenzen möglicherweise nicht auf die Seitengrenzen des Betriebssystems.)
Der InnoDB-Pufferpool Wenn Sie hauptsächlich InnoDB-Tabellen benutzen, benötigt der InnoDB-Pufferpool wahrscheinlich mehr Speicher als alles andere. Im Gegensatz zum MyISAM-SchlüsselCache speichert der InnoDB-Pufferpool nicht nur Indizes: Er nimmt auch Zeilendaten, den adaptiven Hash-Index (siehe »Hash-Indizes« auf Seite 108), den Eingabepuffer, Sperren und andere interne Strukturen auf. InnoDB nutzt den Pufferpool auch, um Schreibvorgänge verzögern zu lassen, so dass es viele Schreibvorgänge verbinden und sequenziell ausführen kann. Kurz gesagt, InnoDB verlässt sich sehr stark auf den Pufferpool, und Sie sollten ihm auf jeden Fall genügend Speicher reservieren. Das MySQL-Handbuch empfiehlt, bei einem dedizierten Server bis zu 80 % des physischen Speichers der Maschine für den Pufferpool vorzusehen; in Wirklichkeit können Sie sogar noch mehr dafür verwenden, wenn die Maschine viel Speicher besitzt. Wie bei den MyISAM-Schlüsselpuffern können Sie Variablen der SHOW-Befehle oder Werkzeuge wie innotop einsetzen, um die Speichernutzung und die Leistung Ihres InnoDB-Pufferpools zu überwachen. Es gibt kein Äquivalent zu LOAD INDEX INTO CACHE für InnoDB-Tabellen. Falls Sie jedoch versuchen, einen Server aufzuwärmen, und bringen ihn dazu, mit einer großen Last umzugehen, können Sie Abfragen aufrufen, die vollständige Tabellenscans oder vollständige Indexscans durchführen. 1 Theoretisch verhält es sich so: Falls Sie sicherstellen könnten, dass die ursprünglichen 4 KByte Daten immer noch im Cache des Betriebssystems wären, wäre der Lesevorgang nicht erforderlich. Allerdings haben Sie keine Kontrolle darüber, welche Blöcke das Betriebssystem letztendlich im Cache behält. Mit dem fincore-Programm, das unter http://net.doit.wisc.edu/~plonka/fincore/ zur Verfügung steht, können Sie feststellen, welche Blöcke sich im Cache befinden.
Allgemeines Tuning | 299
In den meisten Fällen sollten Sie den InnoDB-Pufferpool so groß machen, wie der verfügbare Speicher es zulässt. Unter seltenen Umständen können große Pufferpools (sagen wir, mit 50 GByte) lange Verzögerungen hervorrufen. So könnte ein großer Pufferpool im Verlauf von Checkpoints oder einfügenden Puffer-Merge-Operationen sehr langsam werden und als Folge des Lockings kann die Nebenläufigkeit ausfallen. Wenn Ihnen solche Probleme begegnen, müssen Sie die Größe des Pufferpools verringern. Sie können die Variable innodb_max_dirty_pages_pct so ändern, dass sie InnoDB anweist, mehr oder weniger schmutzige (modifizierte) Seiten im Pufferpool zu halten. Falls Sie viele schmutzige Seiten zulassen, braucht InnoDB unter Umständen lange zum Herunterfahren, da es beim Beenden die schmutzigen Seiten in die Datendateien schreibt. Sie können es zwingen, schnell herunterzufahren, allerdings muss es dann beim Neustart viele Recovery-Aktionen durchführen, so dass Sie den Beenden-und-Neustart-Zyklus eigentlich nicht beschleunigen können. Wenn Sie vorher wissen, wann Sie herunterfahren müssen, können Sie die Variable auf einen niedrigeren Wert setzen, warten, bis der Reinigungs-Thread den Pufferpool gesäubert hat, und dann InnoDB herunterfahren, sobald die Anzahl der schmutzigen Seiten gering genug ist. Sie überwachen die Anzahl der schmutzigen Seiten, indem Sie sich die Statusvariable Innodb_buffer_pool_pages_ dirty anschauen oder innotop einsetzen, um SHOW INNODB STATUS zu kontrollieren. Das Verkleinern des Wertes der Variablen innodb_max_dirty_pages_pct bietet eigentlich keine Garantie dafür, dass InnoDB weniger schmutzige Seiten in den Pufferpool aufnimmt. Stattdessen steuert es den Schwellenwert, ab dem InnoDB aufhört, »faul« zu sein. Das Standardverhalten von InnoDB sieht vor, dass schmutzige Seiten mit einem Hintergrund-Thread entfernt, Schreibvorgänge zusammengefasst und aus Effizienzgründen sequenziell ausgeführt werden. Dieses Verhalten wird als »faul« bezeichnet, weil es InnoDB erlaubt, das Entfernen von schmutzigen Seiten aus dem Pufferpool so lange zu verzögern, bis es den Platz für andere Daten braucht. Wenn der Prozentsatz an schmutzigen Seiten den Schwellenwert erreicht, entfernt InnoDB die Seiten so schnell, wie es kann, um den Zähler für schmutzige Seiten niedriger zu halten. Der Vorgabewert der Variablen beträgt 90, InnoDB ist also beim Entleeren standardmäßig faul, bis der Pufferpool zu 90 % mit schmutzigen Seiten gefüllt ist. Sie können den Schwellenwert an Ihre Last anpassen, falls Sie die Schreiboperationen ein wenig ausweiten wollen. Verringern Sie den Wert etwa auf 50, wird InnoDB im Allgemeinen veranlasst, mehr Schreiboperationen auszuführen, weil es die Seiten früher entfernt und daher nicht in der Lage ist, die Schreiboperationen ebenfalls stapelweise zu verarbeiten. Weist Ihre Last jedoch viele Schreibspitzen auf, kann ein niedrigerer Wert InnoDB helfen, die Spitzen besser zu kompensieren: Es hat mehr »überschüssigen« Speicher, um schmutzige Seiten aufzunehmen, so dass es nicht warten muss, bis andere schmutzige Seiten auf die Festplatte verschoben werden.
300 | Kapitel 6: Die Servereinstellungen optimieren
Der Thread-Cache Der Thread-Cache nimmt Threads auf, die momentan nicht mit einer Verbindung verknüpft sind, aber für neue Verbindungen bereit sind. Wenn im Cache ein Thread vorliegt und eine neue Verbindung gestartet wird, entfernt MySQL den Thread aus dem Cache und übergibt ihn an die neue Verbindung. Wird die Verbindung geschlossen, setzt MySQL den Thread wieder zurück in den Cache, falls dort Platz ist. Ist kein Platz vorhanden, zerstört MySQL den Thread. Solange MySQL einen freien Thread im Cache hat, kann es sehr schnell auf Verbindungsanforderungen antworten, weil es nicht extra einen neuen Thread erzeugen muss. Die Variable thread_cache_size gibt die Anzahl der Threads an, die MySQL im Cache aufbewahren kann. Wahrscheinlich werden Sie diesen Wert nicht verändern wollen, es sei denn, Ihr Server empfängt viele Verbindungsanforderungen. Um zu überprüfen, ob der Thread-Cache groß genug ist, beobachten Sie die Statusvariable Threads_created. Im Allgemeinen versuchen wir, den Thread-Cache so groß zu halten, dass weniger als 10 neue Threads pro Sekunde erzeugt werden. Oft ist es aber recht einfach, diese Zahl auf unter 1 pro Sekunde zu drücken. Ein guter Ansatz besteht darin, die Variable Threads_connected zu beobachten und zu versuchen, thread_cache_size so groß zu machen, dass der typischen Fluktuation in der Arbeitslast begegnet werden kann. Falls sich z.B. Threads_connected normalerweise zwischen 100 und 200 bewegt, können Sie die Cache-Größe auf 100 setzt. Bleibt die Variable zwischen 500 und 700, sollte ein Thread-Cache von 200 groß genug sein. Stellen Sie es sich so vor: Bei 700 Verbindungen gibt es wahrscheinlich keine Threads im Cache, bei 500 Verbindungen gibt es 200 Threads im Cache, die bereit sind, falls die Last wieder auf 700 steigt. Für die meisten Einsatzzwecke ist es wahrscheinlich nicht notwendig, den Thread-Cache sehr groß zu machen. Allerdings sparen Sie kaum Speicher, wenn Sie ihn klein halten: Das bringt also keine Vorteile. Jeder Thread, der sich im Thread-Cache befindet oder schläft, belegt typischerweise etwa 256 KByte an Speicher. Das ist sehr wenig im Vergleich zu der Menge an Speicher, die ein Thread benutzen kann, wenn eine Verbindung aktiv eine Abfrage verarbeitet. Im Allgemeinen sollten Sie den Thread-Cache groß genug halten, um zu verhindern, dass Threads_created allzu oft erhöht wird. Ist diese Zahl jedoch sehr groß (z.B. viele Tausend Threads), werden Sie ihn sicher verkleinern, da manche Betriebssysteme mit sehr großen Thread-Zahlen nicht gut zurechtkommen, selbst wenn die meisten Threads schlafen.
Der Tabellen-Cache Vom Konzept her ist der Tabellen-Cache vergleichbar dem Thread-Cache, allerdings speichert er Objekte, die Tabellen repräsentieren. Jedes Objekt in dem Cache enthält die geparste .frm-Datei der dazugehörigen Tabelle sowie weitere Daten. Was sich genau in dem Objekt befindet, hängt von der Storage-Engine der Tabelle ab. So enthält es z.B. für
Allgemeines Tuning | 301
MyISAM die Tabellendaten und/oder die Indexdateideskriptoren. Für Merge-Tabellen kann es viele Dateideskriptoren enthalten, da Merge-Tabellen viele zugrunde liegende Tabellen besitzen können. Der Tabellen-Cache kann Ihnen helfen, Ressourcen wiederzuverwenden. Wenn z.B. eine Abfrage Zugriff auf eine MyISAM-Tabelle anfordert, könnte MySQL ihr einen Dateideskriptor aus einem im Cache befindlichen Objekt übergeben, anstatt die Datei zu öffnen. Der Tabellen-Cache kann auch dazu beitragen, dass einige der Ein-/Ausgaben vermieden werden, die erforderlich sind, um eine MyISAM-Tabelle in den Index-Headern als »in Benutzung« zu kennzeichnen.2 Das Design des Tabellen-Cache ist ein wenig MyISAM-zentriert – es handelt sich um einen der Bereiche, in denen (aus historischen Gründen) die Trennung zwischen dem Server und den Storage-Engines nicht vollkommen sauber ist. Der Tabellen-Cache ist für InnoDB nicht ganz so wichtig, da InnoDB nicht so häufig darauf zurückgreift (so besitzt es zum Aufnehmen von Dateideskriptoren eine eigene Version eines Tabellen-Cache). Allerdings profitiert selbst InnoDB von der Speicherung der geparsten .frm-Dateien im Cache. In MySQL 5.1 besteht der Tabellen-Cache aus zwei Teilen: einem Cache mit offenen Tabellen und einen Tabellendefinitions-Cache (die über die Variablen table_open_cache und table_definition_cache konfiguriert werden). Die Tabellendefinitionen (die geparsten .frm-Dateien) sind also von den anderen Ressourcen, wie etwa den Dateideskriptoren, getrennt. Geöffnete Tabellen gelten weiterhin pro Thread, pro benutzter Tabelle. Tabellendefinitionen dagegen sind global und können effizient auch von anderen Verbindungen genutzt werden. Im Allgemeinen können Sie table_definition_cache so hoch einstellen, dass alle Tabellendefinitionen Platz im Cache finden. Wenn es nicht gerade um Zehntausende von Tabellen geht, ist das wahrscheinlich am einfachsten. Wenn die Statusvariable Opened_tables groß ist oder ansteigt, dann ist der TabellenCache nicht groß genug, und Sie sollten die Systemvariable table_cache erhöhen (bzw. in MySQL 5.1 table_open_cache). Der einzige tatsächliche Nachteil, der sich ergibt, wenn der Tabellen-Cache sehr groß ist, sind möglicherweise längere Shutdown-Zeiten, wenn der Server viele MyISAM-Tabellen hat, da die Schlüsselblöcke geleert und die Tabellen als nicht länger geöffnet gekennzeichnet werden müssen. Aus dem gleichen Grund kann auch FLUSH TABLES WITH READ LOCK sehr lange brauchen, bis es fertig ist.
2 Das Konzept einer geöffneten Tabelle kann ein wenig verwirrend sein. MySQL sieht eine Tabelle als sehr oft geöffnet an, wenn unterschiedliche Abfragen gleichzeitig darauf zugreifen, oder sogar, wenn eine einzelne Abfrage sich mehr als einmal auf die gleiche Tabelle bezieht, wie in einer Unterabfrage oder in einem SelbstJoin. Die MyISAM-Indexdateien enthalten einen Zähler, den MyISAM erhöht, wenn die Tabelle geöffnet wurde, und den es verkleinert, wenn sie geschlossen wird. Dadurch kann MyISAM feststellen, wann die Tabelle nicht sauber geschlossen wurde: Wenn es eine Tabelle das erste Mal öffnet und der Zähler nicht auf null steht, wurde die Tabelle nicht sauber geschlossen.
302 | Kapitel 6: Die Servereinstellungen optimieren
Falls Sie Fehler empfangen, die besagen, dass MySQL keine weiteren Dateien öffnen kann (das Dienstprogramm perror verrät Ihnen, was die Fehlernummer bedeutet), müssen Sie vermutlich auch die Anzahl der Dateien vergrößern, die MySQL offen halten darf. Sie erledigen das mit der Servervariablen open_files_limit in Ihrer my.cnf-Datei. Die Thread- und Tabellen-Caches brauchen eigentlich nicht viel Speicher, bringen aber Vorteile mit sich, weil sie Ressourcen aufnehmen. Im Vergleich zu anderen Dingen, die MySQL tun könnte, ist das Erzeugen eines neuen Threads bzw. das Öffnen einer neuen Datei nicht sehr aufwendig, bei einer stark nebenläufigen Last kann sich dieser Aufwand aber schnell vergrößern. Das Speichern von Threads und Tabellen in einem Cache kann daher die Effizienz erhöhen.
Das InnoDB-Data-Dictionary InnoDB besitzt einen eigenen Tabellen-Cache, der wahlweise als TabellendefinitionsCache oder als Data-Dictionary bezeichnet wird und den Sie nicht konfigurieren können. Wenn InnoDB eine Tabelle öffnet, fügt es das dazugehörende Objekt in das Data-Dictionary ein. Jede Tabelle kann bis zu 4 KByte oder mehr an Speicher belegen (obwohl in MySQL 5.1 viel weniger Speicher erforderlich ist). Tabellen werden beim Schließen nicht aus dem Data-Dictionary entfernt. Das größte Problem für die Performance ist – abgesehen von den Speicheranforderungen – das Öffnen der Tabellen und das Berechnen von Statistiken für die Tabellen, das aufwendig ist, weil es viele Ein-/Ausgaben erfordert. Im Gegensatz zu MyISAM speichert InnoDB die Statistiken nicht dauerhaft in den Tabellen, sondern berechnet sie jedes Mal neu, wenn es startet. Diese Operation wird in aktuellen MySQL-Versionen durch einen globalen Mutex serialisiert, kann also nicht parallel ausgeführt werden. Wenn Sie viele Tabellen haben, braucht Ihr Server manchmal Stunden zum Starten und vollständigen Aufwärmen. In dieser Zeit macht er kaum etwas anderes, als auf eine Ein-/Ausgabe-Operation nach der anderen zu warten. Wir erwähnen das hier, damit Sie darüber Bescheid wissen, auch wenn Sie es nicht ändern können. Das stellt normalerweise nur dann ein Problem dar, wenn Sie viele (Tausende oder Zehntausende) große Tabellen haben, die dafür sorgen, dass der Prozess ein-/ausgabegebunden ist. Wenn Sie die InnoDB-Option innodb_file_per_table verwenden (diese wird später in »Den Tablespace konfigurieren« auf Seite 315 beschrieben), gibt es noch eine weitere Grenze bezüglich der Zahl der .ibd-Dateien, die InnoDB geöffnet haben kann. Dafür ist die InnoDB-Storage-Engine zuständig, nicht der MySQL-Server, und die Zahl wird von innodb_open_files kontrolliert. InnoDB öffnet Dateien anders als MyISAM: Während MyISAM den Tabellen-Cache für die Dateideskriptoren der offenen Dateien einsetzt, gibt es in InnoDB keine direkte Beziehung zwischen offenen Tabellen und offenen Dateien. InnoDB benutzt einen einzigen, globalen Dateideskriptor für jede .ibd-Datei. Wenn Sie es sich leisten können, dann ist es am besten, innodb_open_files so groß zu machen, dass der Server alle .ibd-Dateien gleichzeitig offenhalten kann.
Allgemeines Tuning | 303
Das Ein-/Ausgabeverhalten von MySQL anpassen Einige Konfigurationsoptionen haben Einfluss darauf, wie MySQL Daten auf der Festplatte synchronisiert und Wiederherstellungsoperationen (Recovery) durchführt. Sie können die Performance drastisch beeinflussen, weil sie teure Ein-/Ausgabe-Operationen beinhalten. Sie repräsentieren außerdem einen Kompromiss zwischen Leistung und Datensicherheit. Im Allgemeinen ist es teuer, sicherzustellen, dass Ihre Daten sofort und konsistent auf die Festplatte geschrieben werden. Wenn Sie gewillt sind, das Risiko einzugehen, dass ein Schreibvorgang auf die Festplatte es nicht bis zur dauerhaften Speicherung schafft, können Sie die Nebenläufigkeit erhöhen und/oder Ein-/Ausgabe-Wartezyklen verringern. Allerdings müssen Sie selbst entscheiden, welches Risiko Sie eingehen können.
MyISAM-Ein-/Ausgabe verbessern Wir wollen zunächst darüber nachdenken, wie MyISAM die Ein-/Ausgaben für seine Indizes durchführt. Normalerweise reicht MyISAM Indexänderungen nach jedem Schreiben auf die Festplatte durch. Falls Sie jedoch an einer Tabelle viele Änderungen vornehmen, könnte es schneller gehen, wenn Sie diese Schreiboperationen in Form einer Stapelverarbeitung zusammenfassen. Eine Möglichkeit dazu besteht mit LOCK TABLES, das Schreiboperationen aufschiebt, bis Sie die Sperren auf den Tabellen aufheben. Diese Technik eignet sich gut, um die Leistung zu verbessern, da sie es Ihnen erlaubt, exakt zu steuern, welche Schreiboperationen verschoben und welche auf die Festplatte gebracht werden. Sie können genau die Anweisungen angeben, für welche die Schreiboperationen ausgesetzt werden sollen. Es ist auch möglich, mit der Variablen delay_key_write Indexschreibvorgänge aufzuschieben. In diesem Fall werden modifizierte Schlüsselpufferblöcke erst dann geschrieben, wenn die Tabelle geschlossen wird.3 Hier sind die möglichen Einstellungen: OFF
MyISAM schiebt modifizierte Blöcke aus dem Schlüsselpuffer (Schlüssel-Cache) nach jedem Schreiben auf die Festplatte, es sei denn, die Tabelle ist mit LOCK TABLES gesperrt. ON
Es wird verzögertes Schreiben der Schlüssel aktiviert, allerdings nur für Tabellen, die mit der Option DELAY_KEY_WRITE erzeugt wurden. ALL
Alle MyISAM-Tabellen nutzen verzögertes Schreiben der Schlüssel.
3 Die Tabelle kann aus mehreren Gründen geschlossen werden. Beispielsweise könnte der Server die Tabelle schließen, weil es nicht genug Platz im Tabellen-Cache gibt, oder jemand könnte FLUSH TABLES ausführen.
304 | Kapitel 6: Die Servereinstellungen optimieren
Das Verzögern des Schlüsselschreibens kann in manchen Fällen sinnvoll sein, bringt jedoch normalerweise keinen großen Leistungsgewinn. Am nützlichsten ist es bei kleineren Datengrößen, wenn die Lesetrefferrate des Schlüssel-Cache gut, die Schreibtrefferrate hingegen schlecht ist. Es hat auch einige Nachteile: • Wenn der Server abstürzt und die Blöcke noch nicht auf die Festplatte übertragen wurden, wird der Index beschädigt. • Wenn viele Schreiboperationen verzögert werden, dauert es länger, bis MySQL eine Tabelle schließen kann, weil es warten muss, bis die Puffer auf die Festplatte geleert werden. In MySQL 5.0 kann das zu lang anhaltendem Sperren des Tabellen-Cache führen. • FLUSH TABLES kann aus den gerade genannten Gründen sehr lange dauern. Das wiederum kann die Zeit vergrößern, die es dauert, FLUSH TABLES WITH READ LOCK für einen LVM-Schnappschuss oder eine andere Backup-Operation durchzuführen. • Nicht geleerte schmutzige Blöcke im Schlüsselpuffer lassen möglicherweise keinen Platz im Puffer für neue Blöcke, die von der Festplatte gelesen werden sollen. Daher werden vielleicht Abfragen angehalten, während sie darauf warten, dass MyISAM etwas Platz im Schlüsselpuffer schafft. Zusätzlich zu MyISAMs Index-Ein-/Ausgabe können Sie konfigurieren, wie MyISAM versucht, sich nach einer Beschädigung wieder zu erholen. Die Option myisam_recover steuert, wie MyISAM nach Fehlern sucht und diese repariert. Sie müssen diese Option in der Konfigurationsdatei oder auf der Kommandozeile setzen. Sie können den Wert der Option mit dieser SQL-Anweisung anschauen, allerdings nicht ändern (das ist kein Tippfehler – die Systemvariable hat einen anderen Namen als die entsprechende Kommandozeilenoption): mysql> SHOW VARIABLES LIKE 'myisam_recover_options';
Indem Sie diese Option aktivieren, weisen Sie MySQL an, die MyISAM-Tabellen auf Beschädigungen zu überprüfen, wenn es sie öffnet, und zu reparieren bzw. zu regenerieren, falls Probleme bemerkt werden. Sie können die folgenden Werte einstellen: DEFAULT (oder keine Einstellung)
MySQL versucht, jede Tabelle zu reparieren, die als beschädigt gekennzeichnet oder nicht als sauber geschlossen markiert ist. Die Standardeinstellung führt neben der Reparatur keine weiteren Aktionen aus. Im Gegensatz zur Funktionsweise der meisten Variablen ist dieser DEFAULT-Wert nicht die Anweisung, die Variable auf ihren bei der Kompilierung festgelegten Wert zurückzusetzen. Stattdessen bedeutet sie tatsächlich »keine Einstellung«. BACKUP
Veranlasst MySQL, ein Backup der Datendatei in eine .BAK-Datei zu schreiben, die Sie anschließend untersuchen können. FORCE
Sorgt dafür, dass die Reparatur fortgesetzt wird, selbst wenn mehr als eine Zeile aus der .MYD-Datei verloren geht.
Das Ein-/Ausgabeverhalten von MySQL anpassen | 305
QUICK
Überspringt die Regeneration, es sei denn, es gibt Löschblöcke. Dabei handelt es sich um Blöcke mit gelöschten Zeilen, die immer noch Platz einnehmen und für künftige INSERT-Anweisungen wiederverwendet werden können. Das kann nützlich sein, weil die MyISAM-Reparatur bei großen Tabellen eventuell sehr lange dauert. Sie können mehrere Einstellungen verwenden, die dann jeweils durch Kommas getrennt werden. Beispielsweise erzwingt BACKUP,FORCE die Regeneration und erzeugt ein Backup. Wir empfehlen Ihnen, diese Option zu aktivieren, vor allem, wenn Sie nur einige kleine MyISAM-Tabellen haben. Es ist gefährlich, einen Server mit beschädigten MyISAMTabellen zu betreiben, da dies manchmal zu weiteren Datenschäden und sogar zu Serverabstürzen führt. Bei großen Tabellen jedoch kann eine automatische Reparatur unpraktisch sein: Sie veranlasst den Server, alle MyISAM-Tabellen zu überprüfen und zu reparieren, wenn sie geöffnet werden; ein sehr ineffizientes Vorgehen. Während dieser Zeit neigt MySQL dazu, Verbindungen am Verrichten irgendwelcher Arbeit zu hindern. Wenn Sie sehr viele MyISAM-Tabellen haben, ist es wahrscheinlich besser, ein weniger aufdringliches Vorgehen zu wählen, das CHECK TABLES und REPAIR TABLES nach dem Start ausführt. Dennoch ist es sehr wichtig, die Tabellen zu überprüfen und zu reparieren. Die Aktivierung des Memory-mapped-Zugriffs auf die Datendateien ist eine weitere sinnvolle Option zum Verfeinern von MyISAM. Memory-Mapping erlaubt es MyISAM, auf die .MYD-Dateien direkt über den Seiten-Cache des Betriebssystems zuzugreifen, wodurch teure Systemaufrufe vermieden werden. Seit MySQL 5.1 können Sie das Memory-Mapping mit der Option myisam_use_mmap einschalten. Ältere Versionen von MySQL benutzen Memory-Mapping nur für komprimierte MyISAM-Tabellen.
InnoDB-Ein-/Ausgabe-Tuning InnoDB ist komplexer als MyISAM. Daraus folgt, dass Sie nicht nur steuern können, wie es die Daten regeneriert, sondern auch, wie es sie öffnet und auf die Platte schreibt, was die Regeneration und die gesamte Performance stark beeinflusst. Der Regenerationsvorgang bei InnoDB erfolgt automatisch und wird immer dann ausgeführt, wenn InnoDB startet. Allerdings können Sie beeinflussen, welche Aktionen es durchführt. Mehr dazu finden Sie in Kapitel 11. Auch wenn wir die Regeneration beiseite lassen und davon ausgehen, dass niemals etwas abstürzt oder schiefgeht, muss immer noch viel für InnoDB konfiguriert werden. Es besitzt eine komplexe Kette aus Puffern und Dateien, die die Leistung verbessern und ACID-Eigenschaften garantieren sollen. Jedes Teil der Kette kann konfiguriert werden. Abbildung 6-1 zeigt diese Dateien und Puffer. Zu den wichtigsten Dingen, die für die normale Benutzung geändert werden müssen, gehören die Größe der InnoDB-Log-Datei, sowie die Art und Weise, wie InnoDB seinen Log-Puffer leert und wie InnoDB Ein-/Ausgaben durchführt.
306 | Kapitel 6: Die Servereinstellungen optimieren
Pufferpool
Log-Puffer Transaktions-Log-Schreibvorgänge
InnoDB I/O threads SchreibThread
LeseThread
LogThread Betriebssystem-Cache Dateisystem
Tablespace DoublewritePuffer
Datendatei
Datendatei
Kreisförmige sequenzielle Schreibvorgänge
Daten, Indizes, Widerrufen-Logs usw.
Datendatei
Transaktions-Log
LogDatei
LogDatei
LogDatei
Abbildung 6-1: Die Puffer und Dateien von InnoDB
Das InnoDB-Transaktions-Log InnoDB verwendet sein Log, um die Kosten für das Bestätigen von Transaktionen zu verringern. Anstatt nach jedem Bestätigen einer Transaktion den Pufferpool auf die Festplatte zu schreiben, verzeichnet es seine Transaktionen im Log. Die Änderungen, die Transaktionen an den Daten und Indizes vornehmen, werden oft zufälligen Stellen im Tablespace zugeordnet, so dass das Übertragen dieser Änderungen auf die Festplatte zufällige Ein-/Ausgaben erfordern würde. Sie können sich merken, dass zufällige Ein-/ Ausgaben viel teurer sind als sequenzielle Ein-/Ausgaben, weil es mehr Zeit kostet, die richtige Stelle auf der Festplatte zu suchen und zu warten, bis der gewünschte Teil der Festplatte unter dem Lese-/Schreibkopf angekommen ist. InnoDB benutzt sein Log, um diese zufälligen Ein-/Ausgaben in sequenzielle Ein-/Ausgaben umzuwandeln. Sobald das Log sicher auf der Festplatte angekommen ist, sind die Transaktionen permanent, auch wenn die Änderungen noch nicht in die Datendateien geschrieben wurden. Geschieht etwas Schlimmes (wie etwa ein Stromausfall), kann InnoDB das Log erneut abspielen und die bestätigten Transaktionen wiederherstellen. Natürlich muss InnoDB die Änderungen schließlich in die Datendateien schreiben, weil das Log eine feste Größe besitzt. Das Schreiben erfolgt »im Kreis herum«: Wenn es das Ende des Logs erreicht, springt es wieder an den Anfang. Es kann einen Log-Eintrag nicht überschreiben, wenn die Änderungen, die dieser enthält, noch nicht in die Datendateien übertragen wurden, weil dadurch der einzige permanente Datensatz der bestätigten Transaktion gelöscht werden würde. Das Ein-/Ausgabeverhalten von MySQL anpassen | 307
InnoDB benutzt einen Hintergrund-Thread, um die Änderungen intelligent in die Datendateien zu übertragen. Dieser Thread kann Schreibvorgänge zusammenfassen und das Schreiben der Daten aus Gründen der Effizienz sequenziell organisieren. Im Prinzip wandelt das Transaktions-Log die zufälligen Ein-/Ausgabe-Zugriffe auf die Datendatei in vorwiegend sequenzielle Ein-/Ausgabe-Zugriffe auf die Log- und die Datendatei um. Da das Verschieben der Daten im Hintergrund erfolgt, werden Abfragen schneller abgeschlossen und Lastspitzen im Ein-/Ausgabe-System abgefedert. Die Gesamtgröße der Log-Datei wird von innodb_log_file_size und innodb_log_files_ in_group kontrolliert und ist für die Schreib-Performance sehr wichtig. Die Gesamtgröße ist die Summe der Größen der einzelnen Dateien. Standardmäßig gibt es zwei 5-MByteDateien mit insgesamt 10 MByte. Das reicht für eine hochleistungsfähige Arbeitslast nicht aus. Die obere Grenze für die Gesamtgröße des Logs beträgt 4 GByte, und typische Größen für außerordentlich schreibintensive Lasten liegen nur bei Hunderten von Megabyte (vielleicht insgesamt 256 MByte). In den folgenden Abschnitten wird erläutert, wie Sie eine gute Größe für Ihre Last ermitteln. InnoDB benutzt mehrere Dateien für ein einziges umlaufendes Log. Normalerweise müssen Sie die vorgegebene Anzahl der Logs nicht ändern, sondern nur die Größe der einzelnen Log-Dateien. Dazu fahren Sie MySQL sauber herunter, verschieben die alten Logs an eine andere Stelle, konfigurieren MySQL neu und starten es wieder. Achten Sie darauf, dass MySQL sauber und geordnet heruntergefahren wird, oder die Log-Dateien enthalten Einträge, die auf die Datendateien angewandt werden müssen! Beobachten Sie das MySQL-Fehler-Log, wenn Sie den Server neu starten. Nach dem erfolgreichen Neustart können Sie die alten Log-Dateien löschen. Größe der Log-Datei und Log-Puffer: Um die ideale Größe für Ihre Log-Dateien zu ermitteln, m