• Initialisierungsarbeiten
• Administrieren
• Arbeiten mit MySQL
  • Typen
  • Konstanten
  • Weitere Kommandos
  • Import aus Textdateien
  • LOCK und UNLOCK als Alternative zur Transaktion
• Die C-API als Programmierschnittstelle
• Java-Programmierung
• Zugriff per PHP
• Literaturhinweise

Initialisierungsarbeiten

apt install mysql-server
apt install mariadb-server

Zum geregelten Herunterfahren der Datenbank kann das Skript /etc/init.d/mysql verwendet werden, alternativ auch systemctl.

systemctl	Aufruf Skript	Wirkung
systemctl mysql start	/etc/init.d/mysql start	Datenbank starten
systemctl mysql stop	/etc/init.d/mysql stop	Datenbank stoppen
systemctl mysql restart	/etc/init.d/mysql restart	Datenbank neu starten
systemctl mysql status	/etc/init.d/mysql status	Datenbankstatus ermitteln

Um Datenbankbefehle einzugeben, ruft man mit dem Befehl mysql den Interpreter von MySQL, aber auch den von MariaDB auf. Dabei wird hinter der Option -u der Benutzer angegeben. Die Option -p sorgt dafür, dass das Passwort des Benutzers angefordert wird. Als letzter Parameter kann die Datenbank angegeben werden, die verwendet werden soll.

# mysql -u root -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 45
Server version: 5.5.47-0+deb7u1 (Debian)

Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

Administrieren

Anlegen einer Datenbank

mysqladmin create meinedb
mysqladmin drop meinedb

mysql meinedb

[(none)] > create database meinedb;
[(none)] > show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| meinedb            |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
[(none)] > use meinedb;
Database changed
[(meinedb)] > drop database meinedb;
[(none)] >

Passwort ändern

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'

Anlegen eines Benutzers

CREATE USER 'dbuser'@'localhost' IDENTIFIED BY 'geheim';

DROP USER 'dbuser'@'localhost';

CREATE USER 'dbuser'@'%' IDENTIFIED BY 'geheim';

SET PASSWORD FOR 'oc_admin'@'localhost' = PASSWORD('geheim');

create database dbname;
grant all on dbname.* to dbuser;

Um alle Benuter und deren Passwörter anzuzeigen werden die Spalten user, host und password aus der Tabelle mysql.user ausgelesen.

mysql> SELECT user,host,password from mysql.user;
+------------------+-----------+-------------------------------------------+
| user             | host      | password                                  |
+------------------+-----------+-------------------------------------------+
| root             | localhost | *ganzganzfurchtbargeheimundverschlüsselt  |
| root             | obelix    | *ganzganzfurchtbargeheimundverschlüsselt  |
| root             | 127.0.0.1 | *ganzganzfurchtbargeheimundverschlüsselt  |
| root             | ::1       | *ganzganzfurchtbargeheimundverschlüsselt  |
|                  | localhost |                                           |
|                  | obelix    |                                           |
| debian-sys-maint | localhost | *ganzganzfurchtbargeheimundverschlüsselt  |
| oc_admin         | localhost | *ganzganzfurchtbargeheimundverschlüsselt  |
| oc_admin         | %         | *ganzganzfurchtbargeheimundverschlüsselt  |
| dbuser           | %         | *ganzganzfurchtbargeheimundverschlüsselt  |
+------------------+-----------+-------------------------------------------+
10 rows in set (0.02 sec)

Datensicherung und Restauration

$ mysqldump --single-transaction owncloud -u root -p >owncloud.sicher.mysql
Enter password: 

$ mysqldump --single-transaction --all-databases -u root -p > sicher.sql
Enter password: 

Zugriff über das Netzwerk erlauben

bind-address            = 192.168.109.142

Administrationstool mysqlcheck

Arbeiten mit MySQL

Verbindung aufnehmen

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.

show tables; zeigt die Tabellen. describe Tabellenname; zeigt die Struktur einer Tabelle.

Anlegen einer Tabelle

CREATE TABLE artikel (
     id INT NOT NULL PRIMARY KEY,
     bez VARCHAR(100),
     preis DEC(10,2));

Soll der Schlüssel automatisch hochgezählt werden, gibt man AUTO_INCREMENT an. NOT NULL ist dann nicht erforderlich.

CREATE TABLE artikel (
     id INT PRIMARY KEY AUTO_INCREMENT,
     bez VARCHAR(100),
     preis DEC(10,2));

CREATE TABLE kunde (
     id INT PRIMARY KEY AUTO_INCREMENT,
     name VARCHAR(100), adr VARCHAR(255));

CREATE TABLE kauf (
    id INT PRIMARY KEY AUTO_INCREMENT,
    artnr INT, kunr INT,
    FOREIGN KEY (artnr) REFERENCES artikel(id),
    FOREIGN KEY (kunr) REFERENCES kunde(id),
    preis DEC(10,2));

> INSERT INTO artikel (bez, preis) VALUES ('Salatgurke', 12.95);
> INSERT INTO artikel (bez, preis) VALUES ('Handgranate', 99.00);
> SELECT * FROM artikel;
+----+-------------+-------+
| id | bez         | preis |
+----+-------------+-------+
|  1 | Salatgurke  | 12.95 |
|  2 | Handgranate | 99.00 |
+----+-------------+-------+

> INSERT INTO kunde (name) VALUES ('Arnold Willemer');
> INSERT INTO kunde (name) VALUES ('Donald Trump');
> INSERT INTO kunde (name) VALUES ('Eulalia Holzbein');
> INSERT INTO kauf (artnr,kunr,preis) VALUES (1,1,12.50);
> INSERT INTO kauf (artnr,kunr,preis) VALUES (2,2,99.99);

> SELECT artikel.id,kunde.id,kauf.preis
  FROM artikel,kunde,kauf WHERE artikel.id=artnr AND kunde.id=kunr;
+----+----+-------+
| id | id | preis |
+----+----+-------+
|  1 |  1 | 12.50 |
|  2 |  2 | 99.99 |
+----+----+-------+

> SELECT artikel.bez,kunde.name,kauf.preis FROM artikel,kunde,kauf
  WHERE artikel.id=artnr AND kunde.id=kunr;
+-------------+-----------------+-------+
| bez         | name            | preis |
+-------------+-----------------+-------+
| Salatgurke  | Arnold Willemer | 12.50 |
| Handgranate | Donald Trump    | 99.99 |
+-------------+-----------------+-------+

> SELECT * FROM kunde;
+----+------------------+------+
| id | name             | adr  |
+----+------------------+------+
|  1 | Arnold Willemer  | NULL |
|  2 | Donald Trump     | NULL |
|  3 | Eulalia Holzbein | NULL |
+----+------------------+------+
3 rows in set (0,001 sec)
> DELETE FROM kunde WHERE name like "Arnold%";
ERROR 1451 (23000): Cannot delete or update a parent row: a foreign
key constraint fails (`meinedb`.`kauf`, CONSTRAINT `kauf_ibfk_2`
FOREIGN KEY (`kunr`) REFERENCES `kunde` (`id`))
> DELETE FROM kunde WHERE name like "Eulalia%";
> SELECT * FROM kunde;
+----+-----------------+------+
| id | name            | adr  |
+----+-----------------+------+
|  1 | Arnold Willemer | NULL |
|  2 | Donald Trump    | NULL |
+----+-----------------+------+
2 rows in set (0,001 sec)

Typen

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

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

/* 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

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.