In unserer Infrastruktur gibt es einen MariaDB-Server, auf dem jede/r eine eigene Datenbank besitzt. Wenn Du auf hopper angemeldet bist, rufe das Programm mariadb auf, damit Du mit Deiner Datenbank verbunden wirst. Dort kannst Du mit:
SHOW TABLES;
alle Tabellen in der Datenbank anzeigen lassen.
Um eine einfache Tabelle anzulegen, erzeuge sie mit
CREATE TABLE demo (
name VARCHAR(256),
age INTEGER
);
Damit wurde eine Tabelle mit dem Namen demo angelegt und mit einer Spalte mit Namen name, in der jeweils eine maximal 256 Zeichen lange Zeichenkette stehen kann und eine Spalte vom Typ Integer mit dem Name age definiert.
Das Programm mariadb verlässt Du mit quit oder exit.
Mit einer INSERT-Anweisung werden einzeln Zeilen in die Tabelle eingefügt:
INSERT INTO demo values ('ich', 30);
INSERT INTO demo values ('du', 40);
Mit einer SELECT-Anweisung werden alle Zeilen aus einer Anfrage (Tabelle) herausgefiltert, die einem bestimmten Kriterium entsprechen:
SELECT *
FROM demo
WHERE name = 'du' OR age = 40;
Der WHERE-Teil kann weggelassen werden, wenn alle Zeilen ausgegeben werden sollen. Statt des Sternchens kann auch explizit angegeben werden, welche Spalten in welcher Reihenfolge ausgegeben werden sollen:
SELECT age, name
FROM demo;
Mit der UPDATE-Anweisung werden jeweils alle Zeilen verändert, die das mit der WHERE-Klausel bestimmte Kriterium erfüllen:
UPDATE demo
SET name = 'DU'
WHERE name = 'du';
Ähnlich verhält es sich mit der DELETE-Anweisung: Es werden alle Datensätze gelöscht, die das in der WHERE-Klausel bestimmte Kriterium erfüllen:
DELETE FROM demo
WHERE name = 'DU';
Als Gegenstück zum Erzeugen von Tabellen gibt es natürlich auch die Möglichkeit, sie wieder zu entfernen:
DROP TABLE demo;
Damit haben wir schon die Möglichkeit, einfache Tabellen anzulegen, abzufragen und sie zu verändern. Was ein gutes Datenbankdesign ist und warum SQL als so eine mächtige Idee betrachtet wird, dazu gibt es Vorlesungen - und natürlich kannst Du sich selbst mit den entsprechenden Tutorials schlau machen (z.B. https://www.w3schools.com/sql/, https://www.w3schools.com/mysql/, https://mariadb.org/documentation/ ).
Insbesondere der Datentyp Timestamp mit der Belegung DEFAULT ist für viele Anwendungen interessant. Zusätzlich solltest Du schauen, dass das Konzept des Index vertraut ist, um die Bearbeitung von Anfragen mit Bedingungen und sortierten Ausgaben zu beschleunigen.
MySQL/MariaDB betten sich recht angenehm in die Linux-Infrastruktur ein: Zum einen können wir dem Programm mariadb auf der Standardeingabe SQL-Befehle übergeben - was natürlich zum Skripten und Automatisieren recht interessant ist:
mariadb < textdatei_mit_sql_anweisungen.sql
Zum anderen lassen sich die Ergebnisse natürlich auch - wieder automatisiert - recht gut weiterverarbeiten - mit bash, perl, python etc:
echo 'select * from demo' | mariadb -s | tr '\t' '|'
Statt des tr-Aufrufes können wir natürlich auch mit while-read arbeiten - dann muss man allerdings darauf achten, dass von mariadb das Tab-Zeichen als Trenner ausgegeben wird. Für den Fall, dass Felder auch Leerzeichen enthalten können, muss der IFS (Internal Field Separator) auf das Tab-Zeichen reduziert werden:
echo 'select * from demo order by id limit 0,10' | mariadb -s | \
while IFS=$'\t' read -r a b c; do echo "[$a][$b]"; done
mariadb --defaults-file=/var/www/data/mariadb-defaults.cnf -e 'select ...'In mariadb gibt es mittlerweise das Konstrukt insert into ... returning, was insbesondere in Web-Anwendung hilfreich ist, weil man oft direkt nach dem insert die erzeugte ID benötigt:
mariadb -sN -e 'insert into demo (name) values ("moin") returning id'Wie wir mit php auf MySQL/MariaDB zugreifen, findet sich in dem kleinen PHP-Tutorial unter: php.html!
In Java benötigen wir den passenden mariadb-Treiber, den wir in dem Docker in
der tomcat-Installation finden (/opt/tomcat/lib/) und dort *nicht* selbst einbinden müssen.
public class Demo {
public static void main(String[] args)throws Exception{
String userName,password,url;
Connection con;
Statement st;
userName="YOUONHOPPER";
password="YOURDBPASSWORD";
url="jdbc:mariadb://mysql-server:3306/YOURDBNAME";
con=DriverManager.getConnection(url, userName, password);
System.out.println("Connection is successful");
Statement statement = con.createStatement();
ResultSet resultSet = statement.executeQuery("select * from demo");
while(resultSet.next()){
System.out.println(resultSet.getString("name"));
}
con.close();
}
}
Die passenden Daten finden sich wieder in ~/.my.cnf. In einem normalen Java-Programm müssen wir beim Start aber dafür sorgen, dass der Datenbank-Treiber im CLASSPATH liegt.
export CLASSPATH=/opt/tomcat/lib/mariadb-java-client-*.jar
CLASSPATH=.:$CLASSPATH
javac Demo.java && java Demo
Denke daran, dass Passwörter und zumeist auch Server und Datenbank nicht in Quellcode gehören. Eine Variante ist, die Daten aus der .my.cnf herauszulesen:
FileReader in = new FileReader(
String.format("%s/.my.cnf", System.getProperty("user.home")));
Properties cred = new Properties();
cred.load(in);
String url = String.format("jdbc:mariadb://mysql-server:3306/%s", cred.getProperty("database"));
Connection con = DriverManager.getConnection(url, cred.getProperty("user"), cred.getProperty("password"));
Generationen von angehenden Datenbank-Expert:innen haben anhand der bekannten DVD-Rental-Datenbank (sakila, github-sakila) den Umgang mit SQL gelernt. Wenn Du das auch tun möchtest, kopiere die Mariadb-Variante in de Docker-Container, packe das Archiv aus, ersetze alle Vorkommen von sakila durch Deinen Datenbank-Namen und importiere die Tabellen. Achtung, dabei entfernst Du alle bisher dort exisitierenden Tabellen!
scp /home/common/data/sakila-db.tar.gz mydocker:
ssh mydocker
tar -zxvf sakila-db.tar.gz
cd sakila-db
sed -i 's/sakila/demo_db/g' sakila-schema.sql sakila-data.sql
cat sakila-schema.sql sakila-data.sql | mariadb
mariadb -e "insert into city (city,country_id) values ('Bremerhaven',38)"
mariadb -e "
select * from city left join country
on city.country_id = country.country_id
where country.country='Germany'"
Um das Programm mariadb-dump in aktuellen Versionen zu nutzen, ist es besser, die .my.cnf-Datei etwas anzupassen:
[client]
user=demo
password=ihrganzgeheimespasswort
host=mysql-server
[mariadb-client]
database=demo_db
In den Docker-Containern wird die Datei entsprechend erzeugt. In dem hopper-Account kann es sein, dass Du das noch anpassen musst.
Damit kannst Du aber nun den aktuellen Zustand dumpen und das Ergebnis wieder einspielen. Für Testkonstellationen und Backups ist das unentbehrlich.
mariadb-dump --databases demo_db > dump.sql
mariadb < dump.sql
Durch das Wiedereinspielen werden allerdings Tabellen, Trigger und Routinen, die nach dem Dump erzeugt wurden, nicht gelöscht - was aber durchaus bisweilen, um einen je umfassend definierten Zustand zu erzeugen, sinnvoll sein kann. Wir können allerdings innerhalb einer Transaktion die Datenbank komplett entfernen und neu erzeugen:
echo 'DROP SCHEMA IF EXISTS demo_db; CREATE SCHEMA demo_db; USE demo_db; ' > reset.sql
mariadb < reset.sql
# bzw.:
cat reset.sql dump.sql | mariadb
Vergiss also bitte wirklich nicht, dass das in einer Transaktion oder zumindest Sitzung
geschehen muss! Wenn wir nicht wollen, dass die bisherigen Daten gelöscht werden, entfernen wir die entspechenden
Zeilen DROP SCHEMA IF EXISTS... und CREATE SCHEMA ....
Wie Du eine eigene Mariadb-Instanz in Deinem docker-Container oder in der VM verwalten, findest Du unter docker.html.