# Datenbanken # Grundwissen # Anomalien #### Einleitung Wenn wir Datenbanken anlegen oder länger verwenden, können bei falsch programmierten Tabellen sogenannte Anomalien entstehen. Diese Anomalien gilt es zu vermeiden. Hier finden wir einige Anomalien, die in unserer Datenbank auftreten können. #### Mutationsanomalie In der Mutationsanomalie wird ein Wert durch einen Fehler **Falsch geschrieben**. Dies kann einfach durch einen Wert entstehen, für den es mehrere Schreibweisen gibt. z.B. **Straße** und **Strasse**. Dadurch befinden sich dann später verschiedene Schreibweisen von Daten in der Datenbank. Dadurch können wir nicht zuverlässig nach Daten suchen und daher sind die Daten dann nicht richtig verwendbar.
**Vorname****Nachname****Straße****PLZ****Ort**
PeterPetersenHauptstraße 3024944Flensburg
GerdaPetersenHauptstrasse 3024944Flensburg
#### Einfüge Anomalie Bei der einfüge Anomalie handelt es sich um einen Fehler, indem Daten die notwendig sind mit "Dummy Daten" gefüllt werden. Also ungewollten falsch Informationen. Dies können **Null** Werte sein, als auch Werte mit den nicht erwarteten Werten.
**Vorname****Nachname****Straße****PLZ****Ort**
PeterPetersenHauptstraße 30?Flensburg
Keine DatenPetersenHauptstrasse 3024944Flensburg
#### Löschanomalie Bei der Löschanomalie handelt es sich um einen Fehler, der entsteht, wenn Daten ungewollt gelöscht werden und so wichtige Teilinformationen fehlen. Ein Beispiel z.B. wäre, wenn Daten, die sich in einer anderen Tabelle befinden gelöscht werden, kann über den Fremdschlüssel einer Tabelle nicht mehr auf die entsprechenden Daten zugegriffen werden. So entsteht ein Informationsverlust.
**Vorname****Nachname****Straße****PLZ-ID**
PeterPetersenHauptstraße 301
GerdaPetersenHauptstrasse 301
#### Änderungsanomalie Bei der Änderungsanomalie handelt es sich um eine Anomalie, die entsteht, wenn eine Änderung an einem Datensatz weitere Änderungen nach sich zieht. Im Beispiel entsteht dies, wenn der Peter Petersen einen neuen Nachnamen erhält, muss an jeder Stelle, in der dieser Nachname auftaucht, der Name per Hand geändert werden. Dies gilt es auch zu vermeiden! # Normalisierungsformen (NF1 - NF3) #### Einleitung Wenn wir Datenbanken einrichten, wollen wir die Daten haben, die zu keinem Problem führen. Wenn wir eine Datenbank erstellen, deren Tabellen alle 3 Normalisierungsformen erfüllen, haben wir Tabellen, die uns die höchste Performance und Zuverlässigkeit bietet. Daher sollte man versuchen, die Datenbanktabellen nach diesen Regeln anzulegen. Die Regeln müssen nach und nach erfüllt werden, das bedeutet es muss erst die **NF1**, dann die **NF2** und zum Schluss die **NF3** erfüllt sein. Also eine Tabelle, die sich in der **Normalisierungsform 2** befindet, hat automatisch die Anforderungen der **Normalisierungsform 1** erfüllt. #### Normalform 0 (0NF) Eine Tabelle liegt in der **"Nullten Normalform"** vor, wenn die Daten sich einfach in der Tabelle befinden. Das bedeutet, die Daten sind nicht atomar. Das bedeutet wir haben **Redundanzen** in der Datenbank ohne **signifikanten Informationsgewinn**. Dadurch ist unsere Tabelle durch sogenannte Anomalien gefährdet. In dem ersten Beispiel haben wir eine Tabelle mit Kundendaten mit den Bestellungen, die diese getätigt haben. Es gibt in der Tabelle Redundanzen, z.B. **DHL** => **Deutsche Post DHL Group** als auch im Merkmal / Attribut Adresse** bei der Postleitzahl mit der Ortsangabe. Im Weiteren haben wir Probleme, wenn wir z.B. Kunden nach Nachnamen sortieren wollen. Dies ist laut unserer aktuellen Tabelle nicht möglich. [![Normalform0.png](https://pc-wiki.de/uploads/images/gallery/2022-05/scaled-1680-/k4qrVd7NpeEqbfPB-normalform0.png)](https://pc-wiki.de/uploads/images/gallery/2022-05/k4qrVd7NpeEqbfPB-normalform0.png) #### Normalform 1 (1NF) Die Tabelle in der **ersten Normalform** existiert, wenn folgende Bedingungen erfüllt sind: 1. Jedes Merkmal atomar ist 2. Nicht weiter unterteilbar ist 3. Listen aufgelöst sind Es befinden sich in der Tabelle dennoch weiterhin Redundanzen, da diese noch nicht entfernt werden. In der 1. Normalisierungsform werden die Daten nur aufgeteilt, dass wir eine reine Tabelle erhalten, in dem wir die entsprechenden Daten in einzelnen Merkmalen aufgeteilt haben.

Ab wann ein Wert **atomar** ist, hängt vom Nutzungskontext ab. Wenn man gewisse Teilungen nicht benötigt, ist dies nicht unbedingt nötig. In der Praxis empfiehlt sich trotzdem alles möglichst klein aufzuteilen.

[![Normalform1.png](https://pc-wiki.de/uploads/images/gallery/2022-05/scaled-1680-/D3cWXKvZpyZeUE5o-normalform1.png)](https://pc-wiki.de/uploads/images/gallery/2022-05/D3cWXKvZpyZeUE5o-normalform1.png) #### Normalform 2 (2NF) In der zweiten Normalform muss die Tabelle in der ersten Normalform vorliegen, und alle Nichtschlüsselmerkmale voll funktional vom Primärschlüssel abhängen. Unterm Strich bedeutet dies, dass jedes Nichtschlüsselmerkmal aus dem Primärschlüssel ableitbar ist. Merkmale, die von einem Teilschlüssel abhängig sind, müssen in eine eigene Tabelle geschrieben werden. Hier teilen wir also die Tabellen in einzelne Tabellen auf. Um jetzt eine Tabelle in die zweite Normalform zu übernehmen, müssen wir folgende Schritte durchführen: 1. Alle Nichtschlüsselmerkmale, die von einem Teilschlüssel funktional abhängig sind bestimmen. 2. Aus den Teilschlüsseln mit allen funktional abhängigen Nichtschlüsselmerkmalen eigene Tabellen bilden. 3. Im letzten Schritt entfernen wir alle nicht voll funktional abhängigen Nichtschlüsselmerkmale. [![Normalform2.png](https://pc-wiki.de/uploads/images/gallery/2022-05/scaled-1680-/PaXH2BYRZgQ3tEv8-normalform2.png)](https://pc-wiki.de/uploads/images/gallery/2022-05/PaXH2BYRZgQ3tEv8-normalform2.png) ##### Normalform 3 (3NF) Im letzten Schritt entfernen wir die letzten Redundanzen. Laut der Definition ist eine Tabelle in der Normalform 3, wenn jedes Schlüsselmerkmal nicht transitiv vom Primärschlüssel abhängig ist. Im Weiteren bedeutet **Transitiv**, dass ein Merkmal einen Umweg nutzen kann, um funktional abhängig von einem anderen Merkmal abhängig ist. Unterm Strich sollen alle Merkmale nur von einem Primärschlüssel abhängig sein. Um eine Tabelle in die dritte Normalform zu übernehmen, verwenden wir folgende Schritte: 1. Alle Nichtschlüsselmerkmale, die transitiv vom Schlüssel abhängen, bestimmen. 2. Im nächsten Schritt sollen aus diesen transitiv abhängigen Nichtschlüsselmerkmalen und den Nichtschlüsselmerkmalen, von denen diese funktional abhängig sind, eigene Tabellen bilden. 3. Im letzten Schritt entfernen wir alle transitiv abhängigen Nichtschlüsselmerkmale aus der Ursprungstabelle. [![Normalform3.png](https://pc-wiki.de/uploads/images/gallery/2022-05/scaled-1680-/cm15ymeJcwRhRQGX-normalform3.png)](https://pc-wiki.de/uploads/images/gallery/2022-05/cm15ymeJcwRhRQGX-normalform3.png) # Microsoft SQL (MSSQL) # JOIN Tabelle in andere Tabelle auslagern Wenn du zwei Tabellen oder mehr mit JOIN miteinander verknüpfen möchtest, kannst du die Tabelle auch in eine andere Tabelle auslagern. (WICHTIG: Die Tabelle wird bei dem Vorgang erstellt! Du kannst also keine schon existierende Tabelle verwenden.) ```SQL SELECT p.Stadtname, p.PLZ, c.Country INTO tblLaender FROM tblPlace p INNER JOIN tblCountry c ON p.ID = c.ID; ``` Du erhältst nun die Ausgabe der JOIN Tabelle in eine andere Tabelle. Du kannst diese jetzt wie gewohnt in SQL weiterverwenden. Die alten Tabellen könntest du dann aus theoretischer Sicht löschen. # MySQL / MariaDB # Alle Benutzer in MySQL / MariaDB anzeigen #### Einleitung Beim Arbeiten mit Datenbanken möchtest du vielleicht einmal nachschauen, welche Benutzer noch angelegt sind, und welchen Zugriff auf die Datenbanken haben. Alte Benutzer können ein sehr hohes Sicherheitsrisiko darstellen, daher sollten Benutzer, die nicht mehr verwendet werden, umgehend beseitigt werden. #### Alle Benutzer anzeigen Um alle Benutzer anzeigen zu lassen, setzt du folgenden Befehl in der SQL Shell ab ```SQL SELECT * FROM mysql.user; ``` Du bekommst dann eine Tabelle zurückgegeben, mit allen Benutzern, die noch angelegt sind, mit Informationen darüber, von welchem Host diese sich anmelden dürfen, wie der Benutzername ist und eine Angabe über das Passwort, natürlich in verschlüsselter Form. Des Weiteren sieht man die Berechtigungen auf den MySQL Server vom jeweiligen Benutzer. # Datenbanken in MySQL / MariaDB anlegen #### Einleitung Um Daten längerfristig zu speichern, bieten sich Datenbanken an. Datenbanken haben den entscheidenden Vorteil das sich mehrere Benutzer gleichzeitig dort anmelden können. Dadurch können Daten schnell und effizient abgefragt werden. #### Datenbank anlegen Wenn du eine Datenbank anlegen möchtest, musst du dir zuerst einen Namen für diese Ausdenken. Der Name darf Buchstaben von **A-Z** ohne Umlaute enthalten. Ein Datenbank Namen darf auch keine führende Zahl enthalten. Des weiteren können Sonderzeichen verwendet werden, aber es können nicht alle Sonderzeichen für Datenbank Namen verwendet werden. Beispielweise kann ein Bindestrich (-) nicht verwendet werden, ein Unterstrich(\_) ist aber in Ordnung. Wenn du dich nun für einen Namen entschieden hast, kannst du nun deine Datenbank erstellen. ```SQL CREATE DATABASE ; ``` # MySQL / MariaDB Verbindung von Außen erlauben #### Einleitung In diesem Beitrag gehe ich kurz darauf ein, wie wir auf unserem Linux Server, auf dem **MySQL** oder **MariaDB** läuft, Verbindungen von Außen zulassen. Dies benötigen wir z.B. wenn wir eine Applikation nutzen wollen, die auf einem anderen Server läuft als unsere Datenbank. Dafür müssen wir eine Konfigurationsdatei editieren.

**Bedenke:** Eine Eröffnung von neuen Wegen zum Zugriff auf Server stellen immer neue Sicherheitsrisiken dar! Stelle sicher das dass Risiko bekannt ist!

#### MySQL Um in MySQL Verbindungen von Außen zu erlauben, müssen wir die Konfigurationsdatei mit einem Editor unserer Wahl öffnen. Ich verwende dazu **nano**. Dieser ist auf fast allen Linux Distributionen vorinstalliert und lässt sich sehr leicht verwenden. ```bash sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf ``` Dort müssen wir den Punkt **bind-address** finden. Dort müsste aktuell die **localhost Adresse (127.0.0.1)** stehen. Diesen Wert ändern wir auf **0.0.0.0**, um von allen Servern den Zugriff zu erlauben. Möchten wir aber, dass der Zugriff nur von einem bestimmten Server möglich sein soll, setzen wir dort die **IP-Adresse des Servers** ein. ```bash # # Instead of skip-networking the default is now to listen only on # localhost which is more compatible and is not less secure. bind-address = 0.0.0.0 ``` Zum Schluss müssen wir nur noch den MySQL Service neu starten. Danach sollte eine Verbindung möglich sein. ```bash sudo systemctl restart mysql ``` #### MariaDB In MariaDB funktioniert das fast genauso wie in MySQL. Es verändert sich lediglich nur die Konfigurationsdatei, die wir öffnen und editieren müssen. Ich verwende hier wieder **nano**, um die Konfigurationsdatei zu öffnen. ```bash sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf ``` Bei dieser Datei müssen wir auch den Punkt **bind-address** finden und diese dann auf die **IP-Adresse** **0.0.0.0** setzen. Natürlich können wir hier auch wieder die **IP-Adresse** des **Servers** eintragen, welcher Zugriff auf den SQL Server haben soll. Im Anschluss starten wir auch den MySQL Dienst wieder neu. ```bash sudo systemctl restart mysql ``` # Backup einer MySQL Datenbank erstellen #### Einleitung Es ist immer ratsam, Backups von einem System zu erstellen. Wir werden hier den Befehl `mysqldump` verwenden. Dieser kann dazu verwendet werden, um Backups einer bestimmten Datenbank oder mehreren Datenbanken zu erstellen. #### Backup einer Datenbank Um ein Backup einer Datenbank zu erstellen, brauchen wir den Namen der entsprechenden Datenbank. Wir können uns alle Datenbanken anzeigen lassen, mit dem folgenden Befehl in der **MySQL Shell**. ```sql SHOW DATABASES; ``` Im Beispiel erstellen wir ein Backup der Datenbank **\_erp\_prod**. Um dieses Backup zu erstellen, verwenden wir dann den folgenden Befehl. Bei dem Befehl müssen wir nur den **Datenbank-Namen** und den Namen der **Backup-Datei** ändern. ```bash mysqldump -u root -p _erp_prod > backup.sql ```

Der Befehl wird aus der **Linux-Shell** abgesetzt, nicht aus der **MySQL-Shell**!

Wir erhalten dann die Backup-Datei in unserem aktuellen Verzeichnis und können diese dann sichern, oder auf einem anderen Server wieder einspielen. #### Backup mehrerer Datenbanken in einer Datei Um mehrere Datenbanken in einer Datei zu sichern, verwenden wir einen ähnlichen Befehl. Dabei verändern wir wieder die Namen der Datenbanken und der Backup-Datei. ```bash mysqldump -u root -p --databases datenbank_eins datenbank_zwei > backup.sql ``` Die beiden Datenbanken befinden sich dann jetzt in der einen **.sql** Datei und können diese auch wieder woanders sichern oder einspielen. #### Alle Datenbanken in einer Datei sichern Wenn wir jetzt alle verfügbaren Datenbanken in einer Datei sichern möchten, müssen wir lediglich den folgenden Befehl verwenden. Dann wird wieder eine Backup-Datei erstellt und alle Daten der Datenbanken werden in diese Datei geschrieben. ```bash mysqldump -u root -p --all-databases > alle_datenbanken.sql ``` #### Datenbanken in verschiedenen Dateien sichern Jetzt zum Schluss können wir die einzelnen Datenbanken in jeweils einer eigenen Datei sichern. Dazu verwenden wir ein **Bash-Skript** welches wir auf unserem Server ausführen. Es werden dann einzelne Dateien angelegt, die den Inhalt der jeweiligen Datenbank haben. ```sh for DB in $(mysql -e 'show databases' -s --skip-column-names); do mysqldump $DB > "$DB.sql"; done ``` # Backup einer MySQL Datenbank einspielen #### Einleitung Sobald wir ein Backup einer **MySQL Datenbank** erstellt haben, möchten wir diese vielleicht auch auf einen anderen Server spielen. Dies machen wir, wenn wir z.B. den **Datenbankserver** umziehen möchten. Dazu brauchen wir die **mysqldump** Datei. Diese haben wir erstellt, als wir das Backup angelegt haben. #### Backup einspielen Wir müssen zuerst, in den meisten Fällen, erstmal die Datenbank anlegen, bevor wir ein Backup für die Datenbank einspielen können. Dazu verwenden wir den `CREATE DATABASE` Befehl. ```sql CREATE DATABASE ; ``` Wenn wir die Datenbank angelegt haben, können wir mit dem unten stehenden Befehl die Datenbank mit den Daten des Backups befüllen. Dazu geben wir noch den Namen der Datenbank ein, und den Pfad zur Backupdatei. Dadurch wird das Backup dann in die angegebene Datenbank eingespielt. ```bash mysql datenbank_name < backup.sql ``` #### Datenbank aus einer großen Backupdatei wiederherstellen Wir können auch, wenn wir eine Datenbankdatei haben, welche mehrere Datenbanken beinhaltet, nur eine Datenbank wiederherstellen. Der Befehl wird dann durch einen weiteren Parameter erweitert. ```bash mysql --one-database datenbank_name < backup.sql ``` Dadurch wird nur die Datenbank mit dem entsprechenden Namen wiederhergestellt. Dabei müssen wir beachten, dass die Datenbank vorher auf dem Server angelegt sein muss. # Auto_Increment in MySQL / MariaDB zurücksetzen #### Einleitung Mit dem SQL-Befehl `AUTO_INCREMENT `können wir eindeutig identifizierbare Datensätze in der Datenbank erstellen. Die ID zählt sich von alleine immer um einen hoch. Wenn wir diese **ID** zurücksetzen wollen, müssen wir entweder die Tabelle neu anlegen, oder wir können einen Befehl verwenden, um die **ID** zurückzusetzen. #### Auto\_Increment zurücksetzen Wenn wir die **ID** zurücksetzen möchten, müssen wir lediglich nur den nachstehenden Befehl auf unserem Server abschicken. Wir müssen dabei nur den Tabellen-Namen anpassen. ```sql ALTER TABLE tabellen_name AUTO_INCREMENT = 1; ``` # SQL Befehle In diesem Kapitel findet man alle möglichen SQL Befehle. Je nach Art des SQL Servers (MySQL / Postgresql / Microsoft SQL) kann die Syntax unterschiedlich sein. Bitte entsprechend informieren wenn es zu Problemen oder Fehlermeldungen kommt. # String in einer Tabelle ersetzen #### Einleitung In diesem Beitrag gehe ich drauf ein, wie wir mit einem SQL Befehl einen String in einem Tabellensatz durch einen anderen String ersetzen können. Dabei wird jedoch nur der entsprechende Teil ersetzt, also es wird nicht der ganze Inhalt der Zelle gelöscht. #### String ersetzen Um den String in einer Tabelle zu ersetzen, müssen wir zuerst in die **Datenbank** wechseln, in dem sich die entsprechenden Tabellen befinden. Dazu verwenden wir den Befehl `use`. ```sql use _production; ``` Im nächsten Schritt verwenden wir den **SQL Befehl** `REPLACE`, um den String zu setzen, wir müssen in dem Befehl angeben, in welchem Attribut sich die zu ersetzenden Werte befinden, und geben im Anschluss den zu suchenden Wert und den Wert ein, der dann eingetragen werden soll. ```sql UPDATE SET = REPLACE(, "", "" ``` Wenn wir dies auf ein Praxisbeispiel anwenden, könnte der Befehl so aussehen: ```sql UPDATE customer SET street = REPLACE(street, "Strasse", "Straße"); ``` # Postgresql # Benutzer in Postgresql anlegen #### Einleitung In diesem Beitrag erläutere ich kurz, wie wir unter **Postgresql** einen Benutzer erstellen können und die entsprechenden Berechtigungen auf eine Datenbank zuweisen können. #### Benutzer anlegen Im ersten Schritt müssen wir einen Benutzer anlegen, dazu überlegen wir uns einen Benutzernamen als auch ein Kennwort für den Benutzer. Mit diesem Kennwort meldet sich der Benutzer in der Zukunft an. ```sql CREATE USER WITH PASSWORD ''; ``` #### Datenbank anlegen Jetzt im zweiten Schritt müssen wir eine Datenbank anlegen. Bei dem Namen der Datenbank denken wir uns wieder einen Namen aus. Sinn macht ein Name, der eindeutig auf ein Projekt oder Programm zuweisbar ist. So weiß man immer, welche Daten in der Datenbank liegen. ```sql CREATE DATABASE ; ``` #### Berechtigungen erteilen Im letzten Schritt müssen wir jetzt nur noch dem Benutzer Zugriff auf die Datenbank erteilen. Wir erteilen dem Benutzer mit dem folgenden Befehl alle Berechtigungen **NUR** für diese Datenbank. Da wir davon ausgehen, dass der Benutzer Tabellen in der Datenbank erstellen, löschen und bearbeiten soll. ```sql GRANT ALL PRIVILEGES ON DATABASE to ; ```