Datenbank-Debugging

Datenbankdebugging-Techniken

Methoden und Werkzeuge zum Debuggen von SQL-Abfragen und Datenbankproblemen in XOOPS-Anwendungen.

Diagnose-Flowchart

flowchart TD
    A[Datenbankproblem] --> B{Abfrage läuft?}
    B -->|Nein| C[Syntax prüfen]
    B -->|Ja| D{Korrekte Ergebnisse?}

    C --> C1[In MySQL CLI ausführen]
    C1 --> C2[EXPLAIN-Plan prüfen]
    C2 --> C3[SQL reparieren]

    D -->|Nein| E[Logik prüfen]
    D -->|Ja| F{Leistung OK?}

    E --> E1[Ergebnismenge protokollieren]
    E1 --> E2[Daten verifizieren]
    E2 --> E3[Abfrage reparieren]

    F -->|Langsam| G[Optimieren]
    F -->|Schnell| H[Debugging abgeschlossen]

    G --> G1[Indizes hinzufügen]
    G1 --> G2[Abfrage umgestalten]
    G2 --> G3[Neu testen]

Abfrageprotokollierung aktivieren

Methode 1: XOOPS Debug-Modus

<?php
// In mainfile.php
define('XOOPS_DEBUG_LEVEL', 2);

// Now all queries appear in xoops_log table
// Or in files: xoops_data/logs/
?>

Ergebnisse überprüfen:

# Protokolle anzeigen
tail -100 xoops_data/logs/*.log

# Oder Datenbank abfragen
SELECT * FROM xoops_log ORDER BY created DESC LIMIT 20;

Methode 2: MySQL Slow Query Log

Aktivieren Sie in /etc/mysql/my.cnf:

[mysqld]
# Slow Query Logging aktivieren
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 1          # Abfragen > 1 Sekunde protokollieren
log_queries_not_using_indexes = 1

MySQL neu starten:

sudo systemctl restart mysql
# oder
sudo systemctl restart mariadb

Protokoll anzeigen:

tail -100 /var/log/mysql/slow.log

# Oder mit mysqldumpslow analysieren
mysqldumpslow -s t -t 10 /var/log/mysql/slow.log

Methode 3: Allgemeines Abfrageprotokoll

Aktivieren Sie für alle Abfragen (Achtung: große Protokolldateien):

-- Aktivieren
SET GLOBAL general_log = 'ON';
SET GLOBAL log_output = 'FILE';
SET GLOBAL general_log_file = '/var/log/mysql/general.log';

-- Deaktivieren
SET GLOBAL general_log = 'OFF';

-- Anzeigen
SHOW VARIABLES LIKE 'general_log%';

Debug SQL in Code

Abfrageausführung protokollieren

<?php
require_once 'mainfile.php';

$ray = ray();  // If using Ray debugger

// Execute query
$query = "SELECT u.uid, u.uname, COUNT(a.id) as total_articles
          FROM xoops_users u
          LEFT JOIN xoops_articles a ON u.uid = a.author_id
          GROUP BY u.uid
          ORDER BY total_articles DESC";

$ray->label('Query')->info($query);

$result = $GLOBALS['xoopsDB']->query($query);

if (!$result) {
    $ray->error("SQL Error: " . $GLOBALS['xoopsDB']->error);
    exit;
}

// Log results
$data = [];
while ($row = $result->fetch_assoc()) {
    $data[] = $row;
}

$ray->label('Results')->dump($data);
$ray->info("Found " . count($data) . " rows");
?>

Abfrageleistung messen

<?php
$db = $GLOBALS['xoopsDB'];
$ray = ray();

// Measure execution time
$start = microtime(true);

$query = "SELECT * FROM xoops_articles LIMIT 1000";
$result = $db->query($query);

$exec_time = (microtime(true) - $start) * 1000;  // milliseconds

$ray->info("Query executed in: {$exec_time}ms");

// Log slow queries
if ($exec_time > 100) {  // Alert if > 100ms
    $ray->warning("Slow query detected: {$exec_time}ms");
    $ray->info($query);
}
?>

Abfrageergebnisse überprüfen

<?php
$db = $GLOBALS['xoopsDB'];
$ray = ray();

$query = "SELECT * FROM xoops_articles WHERE author_id = 5";
$result = $db->query($query);

// Check if query succeeded
if (!$result) {
    $ray->error("Query failed: " . $db->error);
    exit;
}

// Get row count
$count = $result->num_rows;
$ray->info("Query returned: $count rows");

// Fetch results
$articles = [];
while ($row = $result->fetch_assoc()) {
    $articles[] = $row;
}

// Verify data
if (empty($articles)) {
    $ray->warning("No articles found for author 5");
} else {
    $ray->success("Found " . count($articles) . " articles");
    $ray->dump($articles);
}
?>

Abfrageleistung analysieren

EXPLAIN-Befehl

Verwenden Sie EXPLAIN zur Analyse der Abfrageausführung:

-- Analyze a query
EXPLAIN SELECT * FROM xoops_articles WHERE author_id = 5;

-- With extended information
EXPLAIN EXTENDED SELECT * FROM xoops_articles WHERE author_id = 5;

-- JSON format (shows more details)
EXPLAIN FORMAT=JSON SELECT * FROM xoops_articles WHERE author_id = 5\G

Zu überprüfende Schlüsselfelder:

type: ALL           (schlecht) - Vollständiger Tabellenscan
      INDEX         (ok) - Indexscan
      ref/const     (gut) - Direkte Index-Suche
      range         (ok) - Bereichsscan mit Index

possible_keys:      Verfügbare Indizes
key:                Verwendeter Index
key_len:            Länge des verwendeten Index
rows:               Geschätzte untersuchte Zeilen
Extra:              Zusätzliche Informationen (Using where, Using index, etc.)

Beispielanalyse

-- Slow query without index
EXPLAIN SELECT * FROM xoops_articles WHERE author_id = 5;

+----+-------------+----------+------+---------------+------+---------+------+-------+-------------+
| id | select_type | table    | type | possible_keys | key  | key_len | rows | Extra |
+----+-------------+----------+------+---------------+------+---------+------+-------+-------------+
|  1 | SIMPLE      | articles | ALL  | NULL          | NULL | NULL    | 1000 | Using where |
+----+-------------+----------+------+---------------+------+-------+------+-------+-------------+
                                      ↑
                          Kein Index verfügbar!

-- Nach dem Hinzufügen des Index
ALTER TABLE xoops_articles ADD INDEX (author_id);

EXPLAIN SELECT * FROM xoops_articles WHERE author_id = 5;

+----+-------------+----------+------+---------------+-----------+---------+-------+------+
| id | select_type | table    | type | possible_keys | key       | key_len | rows  | Extra|
+----+-------------+----------+------+---------------+-----------+---------+-------+------+
|  1 | SIMPLE      | articles | ref  | author_id     | author_id | 4       | 10    |
+----+-------------+----------+------+---------------+-----------+---------+-------+------+
                                                              ↑
                                      Index verwenden - viel schneller!

Häufige SQL-Probleme

1. N+1-Abfrage-Problem

Problem:

<?php
// FALSCH: Mehrere Abfragen in Schleife
$authors = $db->query("SELECT uid FROM xoops_users LIMIT 100");
while ($author = $authors->fetch_assoc()) {
    // Dies wird 100 Mal ausgeführt!
    $articles = $db->query(
        "SELECT COUNT(*) FROM xoops_articles WHERE author_id = " . $author['uid']
    );
    echo $articles->fetch_row()[0];
}
?>

Lösung: JOIN verwenden

<?php
// KORREKT: Eine Abfrage
$result = $db->query("
    SELECT u.uid, u.uname, COUNT(a.id) as total
    FROM xoops_users u
    LEFT JOIN xoops_articles a ON u.uid = a.author_id
    GROUP BY u.uid
    LIMIT 100
");

while ($row = $result->fetch_assoc()) {
    echo $row['total'];
}
?>

2. Fehlende Indizes

Identifizieren:

-- Abfragen finden, die alle Zeilen scannen
SELECT * FROM xoops_log
WHERE info LIKE '%type: ALL%'
ORDER BY created DESC;

Indizes hinzufügen:

-- Einzelspalten-Index
ALTER TABLE xoops_articles ADD INDEX (author_id);
ALTER TABLE xoops_articles ADD INDEX (created);

-- Composite Index
ALTER TABLE xoops_articles ADD INDEX (author_id, created);

-- Eindeutiger Index
ALTER TABLE xoops_articles ADD UNIQUE INDEX (slug);

3. Ineffiziente WHERE-Bedingungen