MySQL

MySQL ist eine sehr beliebte Datenbank vor allem im Internetbereich. Sie ist durch die offene Struktur von den wichtigen Serversprachen PERL und PHP leicht anspechbar.

Ursprünglich war MySQL nicht einmal mit einem Transaktionsmechanismus (COMMIT, ROLLBACK) ausgestattet. Der Hersteller begründet die niedrige Priorität dieses Features für die Weiterentwicklung damit, dass dies erhebliche Auswirkungen auf die Performance habe. Und bei dem typischen Einsatzgebiet als Datenbank für Webserver war diese Argumentation durchaus berechtigt. Inzwischen ist auch MySQL transaktionsfähig.

MySQL arbeitet über einen TCP/IP-Server namens mysqld auch dann, wenn die Zielmaschine lokal ist.

Initialisierungsarbeiten

Die Installation geschieht am einfachsten als root. Es ist aber auch möglich und sogar aus Sicherheitsgründen nicht verkehrt, unter einem beliebigen User die Datenbank zu installieren. Zu Beginn muss die Initialisierung der Basisdatenbanken in /var/mysql erfolgen. Dies erreicht der Skript mysql_install_db. Mit safe_mysqld wird der Dämon gestartet. 

mysql_install_db
safe_mysqld &

Zum geregelten Herunterfahren des Services dient der dritte Befehl: 

mysqladmin -u root shutdown

Zum Test, welche Datenbanken eingerichtet sind, dient der Befehl mysqlshow, der eine Liste aller bekannten Datenbanken zeigt.

Administrieren

Der Server erhält mit folgenden Befehlen ein root-Passwort. 

/usr/bin/mysqladmin -u root password 'new-password'
/usr/bin/mysqladmin -u root -h onyx.willemer.edu password 'new-password'

Der mysql-Dämon wird über den normalen Start-Skript unter /etc/init.d/mysql gestartet. 

/etc/init.d/mysql start

Anlegen eines Benutzers

Der Administrator kann neue Benutzer anlegen. Hier wird ein User namens benutzer mit dem Passwort geheim angelegt. 

CREATE USER benutzer IDENTIFIED BY 'geheim';
Mit dem Befehl DROP USER wird der Benutzer wieder gelöscht. 
DROP USER benutzer
Das Tool mysql-administrator ermöglicht Adminstrationsarbeiten mit einer grafischen Benutzeroberfläche. Hier können beispielsweise auch Benutzer angelegt werden.

Arbeiten mit MySQL

Zum Arbeiten mit der Datenbank steht neben den Programmierschnittstellen eine Client-Kommandozeile namens mysql zur Verfügung. Hier können SQL-Kommandos abgesetzt werden. Der SQL-Standard braucht hier nicht noch einmal erläutert zu werden, da er an anderer Stelle bereits ausgeführt ist.

Verbindung aufnehmen

Zunächst schauen Sie nach, welche Datenbanken überhaupt angelegt wurden. Sie können sich bei einer Datenbank mit dem folgenden Befehl anmelden. 

mysql -D dbname -u user -p

Anschließend wird das Passwort des Benutzers erfragt.

Danach können Sie die üblichen SQL-Befehle absetzen. Vergessen Sie nicht das Semikolon am Ende der Zeile!

Einige Befehle sind spezifisch für mysql. Der Befehl status (hier ohne Semikolon) zeigt den Status von mysql.

show databases; zeigt die eingerichteten Datenbanken.

Typen

TINYINT 8 Bit
SMALLINT 16 Bit
MEDIUMINT 24 Bit (kein Standard!)
INTEGER oder INT 32 Bit
BIGINT 64 Bit
FLOAT oder FLOAT(4) 4 Byte (max. ca. 10+-38
DOUBLE, REAL oder FLOAT(8) 8 Byte (max. ca. 10+-308
NUMERIC(m,d) oder DECIMAL(m,d) m Byte, sofern m>d, da Stringdarstellung
DATE '1000-01-01' bis '9999-12-31'
DATETIME '1000-01-01 00:00:00' bis '9999-12-31 23:59:59'
TIME '-838:59:59' bis '838:599:59'
CHAR(n) n von 1 bis 255
VARCHAR(n) n von 1 bis 255, nimmt nur soviel Platz wie benötigt ein
TEXT oder BLOB Länge max 216 - 1
MEDIUMTEXT oder MEDIUMBLOB Länge max 224 - 1
LONGTEXT oder LONGBLOB Länge max 232 - 1

Numerische Typen haben optional UNSIGNED. CHAR und VARCHAR können das Attribut BINARY haben. Dies führt dazu, dass eine Sortierung case sensitive ist.

Konstanten

Das Dezimalzeichen ist der Punkt. Strings können durch " und durch ' eingeschlossen werden. Die \-Escapes sind wie die unter C, hinzu kommt \% und \_, da dies ansonsten Wildcards in SQL-Ausdrücken sind.

Weitere Kommandos 

CREATE DATABASE Datenbankname
DROP DATABASE Datenbankname
USE DATABASE Datenbankname

Mit CREATE wird eine Datenbank angelegt. In dieser werden die Tabellen erzeugt. Mit DROP wird die Datenbank und alle ihre Tabellen gelöscht. Mit USE wird die Datenbank gewechselt. 

OPTIMIZE TABLE Tabellenname

Nach umfangreichem Löschen oder Ersetzen von variablen Feldern kann es sich lohnen, die Tabelle zu optimieren.

MySQL kennt den Befehl REPLACE, der eine Kombination aus DELETE und INSERT auf einer Tabelle mit einem UNIQUE KEY ist.

Import aus Textdateien 

LOAD DATA [LOCAL] INFILE 'filename.txt
     INTO TABLE tablename
     [FIELDS [TERMINATED BY '\t'] [OPTIONALLY] ENCLOSED BY " [ESCAPED BY '\\']]
     [LINES TERMINATED BY '\n']
     [(columnname [,columname]*)]

LOCAL bedeutet, dass die Textdatei auf dem Clienthost steht. Fehlt die Angabe, befindet sie sich auf dem Server. Bei letzterem ist der Import natürlich schneller. Man braucht allerdings die entsprechenden Berechtigungen.

Die oben angegebenen Optionen sind der Standard. Ohne Angaben erwartet MySQL also die Felder optionall durch Anführungszeichen begrenzt, aber durch Tabulatorzeichen getrennt und alle Zeilen durch ein Linefeed getrennt.

LOCK und UNLOCK als Alternative zur Transaktion 

LOCK TABLES tablename { READ | WRITE }
           [, tablename { READ | WRITE } ]*

READ bedeutet, dass alle Prozesse nur noch auf der Tabelle lesen dürfen. WRITE bedeutet, andere Prozesse dürfen weder Lesen noch Schreiben. Die Sperre wird aufgehoben durch UNLOCK TABLES

Die C-API als Programmierschnittstelle

Für den Zugriff auf die MySQL-Datenbank sind folgende Typen wichtig:
MYSQL Handle zu einer Datenbankverbindung
MYSQL_RES Ein Anfrageresultat, also quasi eine Ergebnistabelle
MYSQL_ROW Ein Ergebniszeile, kann als Array of Strings zugegriffen werden
Ein C-Programm muss zun¨chst <mysql/mysql.h> einbinden. Beim Übersetzen wird die Library mysqlclient angehängt. Je nach UNIX-Version kann dies das explizite Einbinden der socket erforderlich machen. 

/* Demonstration fuer den Zugrff auf MySQL ueber die C-API.
 * (C) Arnold Willemer
 */

#include <mysql/mysql.h>

/* prototypes */
void dbInsert(MYSQL *dbHandle);
void dbSelect(MYSQL *dbHandle);

void main()
{
  MYSQL *     dbHandle;

  dbHandle = mysql_init(0);
  dbHandle = mysql_real_connect(dbHandle,
        "localhost",   /* on what host */
        "arnold",      /* the user */
        0,             /* no password */
        "test_arnold", /* the database */
        0,             /* don't change the port number */
        0,             /* don't change the UNIX socket */
        0);            /* client flag */
  if (dbHandle==0) {
    puts("no connect to database");
    return;
  }

  dbInsert(dbHandle);
  dbSelect(dbHandle);

  /* at last close the connection */
  mysql_close(dbHandle);
}

void dbInsert(MYSQL *dbHandle)
{
  if (0!=mysql_query(dbHandle, 
        "INSERT INTO customer(nr, name) VALUES (12, 'Hans Wurst')")) {
    puts("query INSERT was not successful");
  }
}

void dbSelect(MYSQL *dbHandle)
{
MYSQL_RES * dbResult;
MYSQL_ROW   dbRow;
unsigned long *fieldLengths;
unsigned int i, fieldNumbers;

  if (0!=mysql_query(dbHandle, "SELECT * FROM customer")) {
    puts("query was not successful");
  } else {
    /* now we fetch the results to a local buffer */
    dbResult = mysql_store_result(dbHandle);
    if (dbResult==0) {
      puts(" problem with the result ");
    } else {
      fieldNumbers = mysql_num_fields(dbResult);
      while ((dbRow = mysql_fetch_row(dbResult))) {
        fieldLengths = mysql_fetch_lengths(dbResult);
        for(i = 0; i < fieldNumbers; i++) {
          if (dbRow[i]==0) {
            printf(" (null) ");
          } else {
            printf("%s - ",  dbRow[i] );
          }
        }
        printf("\n");
      }
    }
    mysql_free_result(dbResult);
  }
}

Die Anmeldung und Abmeldung erfolgen mit kurzen klaren Schritten. Es wird der Zielhost, der Benutzer und sein Passwort benötigt. Auch die Datenbank wird angegeben.

Das Einfügen von Daten kann wie alle SQL-Befehle, die keine Antwort brauchen recht einfach bewerkstelligt werden, indem ein String konstruiert wird, der an die Datenbank gesandt wird.

Aufwenig wird es wenn ein SELECT eine Menge von Datensätzn liefert. Dies passt nicht zu den satzorientierten Systemen und Programmiersprachen. Dementsprechend wird hier immer ein recht umständlicher Aufwand betrieben, um dem Mengenparadigma von SQL zu genügen. Im Falle von MySQL wird zunächst ermittelt, Zeile für Zeile geholt und dann spaltenweise ausgewertet.

Eine vergleichbare Schnittstelle existiert auch zu PHP.

Java-Programmierung

Der Zugriff auf Datenbanken erfolgt von Java aus per JDBC. Ein typischer Beispielcode lautet: 

import java.sql.*;

class testMySQL {
    public static void main(String argv[]) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection connection =
                DriverManager.getConnection(
                    "jdbc:mysql://localhost/meinedb",
                    "user",
                    "password");
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery("select * from kunde");
            while (rs.next()) {
                System.out.println("name = " + rs.getString("name"));
            }
        } catch (ClassNotFoundException e) {
            System.out.println("Couldn't load Driver: " + e.getMessage());
        } catch (SQLException e) {
            System.out.println("Couldn't get Connection: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Problem: " + e.getMessage());
        }
    }
}

Das Aktivieren des Treibers hat bei mir nicht geklappt. Erst als ich die jar-Datei mysql-connector-java-version-bin.jar in die Libraries meines Projekts einband, funktionierte der Zugriff.

Literaturhinweise

Stefan Pröll, Eva Zangerle, Wolfgang Gassler: MySQL
Homepage 26.9.2001 (C) Copyright 2001-2007, 2011 Arnold Willemer