Der reinen Datenbank-Lehre nach ist es strikt verboten mehrere Werte auf einem Attribut zu speichern. Sowas kommt in der Realität trotzdem vor, sogar bei Fremdschlüssel-Attributen. D.h. das Fremdschlüssel-Attribut referenziert in dem Fall nicht nur eine, sondern mehrere Zeilen. Die gute Nachricht ist, dass MySQL es erlaubt, für so ein - ansich unterlaubtes - Design mithilfe der Funktion find_in_set() eine Join-Condition zu formulieren.

Beispiel

Gegeben zwei Tabellen TableA und TableB, wobei Attribut TableB.tablea_id auf mehrere Zeilen in TableA verweist.

TableA    TableB

id        id tablea_id
--        -- ---------
1         1  2,3
2         2  3
3         3  1,2,3,4
4         4  NULL

Wäre TableB.tablea_id ein normales Fremdschlüssel-Attribut mit einem Wert sähe die Join-Condition so aus:

TableA.id = TableB.tablea_id

Diese Bedingung ist hier nicht anwendbar, da eine Identität (=) zwischen TableA.id und TableB.tablea_id nur manchmal gegeben ist.

Die Selektion

SELECT
    b.id b_id
    , a.id a_id
FROM
    TableA a
    INNER JOIN TableB b
    ON a.id = b.tablea_id
ORDER BY
    b.id
    , a.id

liefert ein falsches Resultat

+------+------+
 b_id | a_id |
+------+------+
|    1 |    2 | zweifelhaft
|    2 |    3 | erwartet
|    3 |    1 | zweifelhaft
+------+------+

Da MySQL bei numerischen Identitäts-Vergleichen eine laxe Auffassung hat und gegen den numerischen Anfang einer Zeichenkette vergleicht, auch wenn die Zeichenkette insgesamt keine Zahl darstellt, ist die Ergebnismenge zusätzlich zweifelhaft. Statt der erwarten einen Zeile werden drei Zeilen geliefert.

MySQL besitzt jedoch eine Funktion find_in_set(), mit deren Hilfe eine Join-Condition formuliert werden kann, die die mehrwertigen Verweise korrekt auflöst:

FIND_IN_SET(TableA.id, TableB.tablea_id) > 0

Die Selektion

SELECT
    b.id b_id
    , a.id a_id
FROM
    TableA a
    INNER JOIN TableB b
    ON FIND_IN_SET(a.id, b.tablea_id) > 0
ORDER BY
    b.id
    , a.id

liefert das korrekte Resultat

+------+------+
 b_id | a_id |
+------+------+
|    1 |    2 |
|    1 |    3 |
|    2 |    3 |
|    3 |    1 |
|    3 |    2 |
|    3 |    3 |
|    3 |    4 |
+------+------+

Links

• MySQL: find_in_set()

Eine MySQL-Datenbank, die von innen (Host oder lokalem Netzwerk), jedoch nicht von außen (Internet) per TCP/IP erreichbar ist, kann von einem entfernten Rechner über einen SSH-Tunnel erreicht werden, wenn man einen SSH-Zugang zu dem Datenbank-Host oder einem Host des Netzwerks besitzt.

1 - SSH-Tunnel zum MySQL Port 3306 aufsetzen:

$ ssh <user>@<host> -L <port>:localhost:3306 -f -N

-L <port>:localhost:3306 : Verbinde lokalen Port <port> remote mit MySQL Port 3306
-f                       : Lege den ssh-Prozess in den Hintergrund
-N                       : Führe remote nichts aus (kein Login, kein Kommando)

2 - Mit der Datenbank verbinden:

$ mysql --host=localhost --port=<port> --protocol=tcp ...

oder

$ mysql --host=127.0.0.1 --port=<port> ...

Dieser spezielle Fall von SSH-Tunneling kann natürlich auch auf andere Dienste (Ports) übertragen werden.

Ein weiterer Artikel zu dem Thema: http://www.revsys.com/writings/quicktips/ssh-tunnel.html

phpMyAdmin

Um mit einer lokalen phpMyAdmin-Applikation über den Tunnel auf die Remote-Datenbank zugreifen zu können, wird eine entsprechende Server-Definition in der phpMyAdmin-Konfiguration vereinbart, z.B. in /etc/phpmyadmin/conf.d/<Server-Name>.php:

<?php

$cfg['Servers'][$i]['verbose'] = '<Server-Name>';
$cfg['Servers'][$i]['host'] = '127.0.0.1';
$cfg['Servers'][$i]['port'] = '3305';
$cfg['Servers'][$i]['connect_type'] = 'tcp';
$i++;

Das Timeout hochsetzen:

$cfg['LoginCookieValidity'] = <Wert in Sekunden>;

Z.B. ein Tag:

$cfg['LoginCookieValidity'] = 86400;

0 bedeutet nicht unendlich, sondern sofortiges Logout!

1. Server herunterfahren

2. Inhalt des Datadir löschen

   $ rm -r DATADIR/*

3. Datadir initialisieren

   $ mysql_install_db --user=mysql --ldata=DATADIR

4. Server wieder hochfahren

Eine elegante Möglichkeit, mehrere MySQL-Instanzen auf einem Server zu betreiben, bietet das Programm mysqld_multi. Es erweitert die Konfigurationsdatei /etc/my.cnf um Abschnitte für mehrere MySQL-Serverinstanzen [mysqld#] (wobei # die jeweilige Instanznummer bezeichnet). In den Abschnitten werden den Instanzen getrennte Datadirs, Sockets, Ports, Pid-Files usw. zugewiesen.

mysqld_multi ist das Frontend-Programm zum Starten und Stoppen der einzelnen Instanzen, à la

$ mysqld_multi start 2

Eine Beispielkonfiguration, die auf die eigenen Verhältnissse angepasst und in my.cnf eingesetzt werden kann, liefert das Kommando

$ mysqld_multi --example

Die ausführliche Doku ist auf der Manpage zu finden:

$ man mysql_multi

Der MySQL Query Optimizer kann bessere Query-Pläne generieren, wenn er Informationen über die Tabelleninhalte hat. Diese können per SQL mit ANALYZE TABLE erzeugt werden oder - einfacher - mit dem Kommandozeilenprogramm mysqlcheck. Die Option zum Analysieren heißt --analyze. Bei Angabe der Option --all-databases werden alle Tabellen aller Schemata (in MySQL-Sprechweise: Datenbanken) auf einen Schlag analysiert. Das ist meistens das, was man will.

$ mysqlcheck --analyze --all-databases ...

bzw. in Kurzform

$ mysqlcheck -a -A ...

Damit der MySQL-Server mysqld TCP-Verbindungen annimmt, muss ihm in my.cnf im Abschnitt [mysqld] eine Bind-Adresse zugewiesen werden:

bind-address = <server-ip>

Falls vorhanden, muss die Direktive skip-networking gleichzeitig auskommentiert werden, da diese Priorität hat und forciert, dass der Server nur Unix Domain Sockets zulässt.

Per SQL einen neuen User anlegen und ihm den Remote-Zugriff von allen Hosts ('%') auf alle Schemata und Tabellen (*.*) erlauben:

CREATE USER <user> IDENTIFIED BY '<password>';
GRANT ALL ON *.* TO '<user>'@'%';

Login mit mysql-Client:

$ mysql -u <user> -h <host> --password=<password>

Die User-Zugriffsberechtigungen stehen in der Tabelle mysql.user. Diese Tabelle kann mit INSERT/UPDATE/DELETE Statements auch direkt manipuliert werden.

Oracle kennt die Pseudo-Kolumne ROWNUM, die die Datensätze einer Selektion von 1 an aufsteigend durchnummeriert. In MySQL existiert dieses Konzept nicht, es kann aber mittels einer Benutzer-definierten Variable simuliert werden.

Implementierung:

Einschränkung: Die Lösung ist unzureichend, wenn ein ORDER BY verwendet wird, da die Nummerierung vor der Sortierung stattfindet.

Unter Oracle wird ROWNUM auch benutzt, um die Ergebnismenge auf die ersten n Datensätze zu begrenzen. Dafür hat MySQL ein besseres Konzept, die SELECT-Klausel LIMIT.