Einführung in die Datenbank beiträgt sich mit Mariadb und MySQL -Beispiele zusammen

Zielsetzung

Erfahren Sie, wie Sie die verschiedenen Art von Verknüpfungen kennenlernen und wie Sie sie mit MySQL- oder MariADB -Datenbanken arbeiten können

Anforderungen

• Keine besonderen Anforderungen

Konventionen

• # - Erfordert, dass der Befehl gegebener Linux entweder mit Root -Berechtigungen ausgeführt werden muss
  direkt als Stammbenutzer oder durch Verwendung von sudo Befehl
• $ - Der Befehl Linux wird als regelmäßiger nicht privilegierter Benutzer ausgeführt

Einführung

In einem relationalen Datenbanksystem werden die Daten in Tabellen organisiert, die durch Zeilen und Spalten zusammengesetzt sind. Jede Zeile ist eine Instanz der Entität, die durch die Tabelle dargestellt wird, wobei die Spalten als Eigenschaften verwendet werden. Die Beziehungen zwischen Tabellen werden durch die Verwendung von Fremdschlüssel und die Aussage, mit der wir Abfragen ausführen können, die über mehrere Tabellen erstrecken können verbinden. In diesem Tutorial sehen wir die verschiedenen Art von Verbindungen, die bei der Verwendung von MySQL oder Mariadb verfügbar sind.

Die Datenbank "Movie_Store"

Was wir in diesem Tutorial tun werden, bedeutet, einige konkrete Fälle zu reproduzieren, in denen Verbindungen uns helfen können, das zu erreichen, was wir wollen.

Das erste, was Sie tun müssen, ist eine Testdatenbank zu erstellen. Angenommen, wir besitzen einen Filmgeschäft und müssen die von uns verfügbaren Titel verfolgen: Wir werden eine "Movie_Store" -Datenbank und eine Tabelle erstellen, um Informationen über die Filmregisseure zu hosten:

Mariadb [(keine)]> Datenbank Movie_Store erstellen; Mariadb [(keine)]> verwenden Movie_Store; Mariadb [Movie_Store]> Tabellenleiter erstellen ( -> ID Smallint (1) Unsigned NOT NULL Auto_increment, -> Name Varchar (35) NICHT NULL, -> BURTYDATE DATUM NICHT NULL, -> Primärschlüssel (ID)); 

Hier ist die visuelle Darstellung der Tabelle, die wir gerade erstellt haben:

Mariadb [Filme]> beschreiben Regisseur; +-----------+----------------------+------+-----+-- --------+ ----------------+ | Feld | Typ | NULL | Schlüssel | Standard | Extra | +-----------+----------------------+------+-----+-- --------+ ----------------+ | id | smallint (1) nicht signiert | Nein | Pri | NULL | auto_increment | | Name | varchar (35) | Nein | | NULL | | | Geburtsdatum | Datum | Nein | | NULL | | +-----------+----------------------+------+-----+---------+----------------+ 

Zuerst haben wir den Database Movie_Store erstellt, als wir sie mit dem „eingegeben“ haben VERWENDEN Anweisung und schließlich die Tabelle Director erstellt. Wie bereits erwähnt, repräsentiert jede Zeile in einer Tabelle eine „Instanz“ der von der Tabelle selbst dargestellten Entität, in diesem Fall ein Filmregisseur.

Jeder Regisseur hat einige Eigenschaften, die durch die Tabellenspalten dargestellt werden. So hat beispielsweise jeder Regisseur einen Namen und einen Geburtstag. Jede Zeile hat eine eindeutige Kennung, die der Wert in der Spalte ist, die die ist Primärschlüssel des Tisches.

In diesem Beispiel ist der Hauptschlüssel auch das, was als a genannt wird Ersatzschlüssel. Diese Art von Schlüssel ist eine „künstliche“ Kennung in dem Sinne, dass sie nicht mit der Art der Entität zusammenhängt (in diesem Fall ein Verzeichnis): Es hat keine semantische Bedeutung und wird vom System für seine erzeugt und verwendet eigene interne Arbeit. Der Schlüssel wird automatisch generiert und da er das hat Auto_increment Eigenschaft, sie wird jedes Mal, wenn wir eine neue Zeile erstellen, schrittweise eingefügt, sodass wir sie nicht explizit einfügen müssen:

Mariadb [Movie_Store]> In Director einfügen ('Name', 'Birthdate') Werte-> ('George Lucas', '1944-05-14'),-> ('George Romero', '1940-02-04' ' ),-> ('John McTiernan', '1951-01-08'),-> ('Rian Johnson', '1973-12-17'); 

Unsere Tabelle enthält jetzt vier Direktoren:

+----+----------------+------------+ | id | Name | Geburtsdatum | +----+----------------+------------+| 1 | George Lucas | 1944-05-14 | | 2 | George Romero | 1940-02-04 | | 3 | John McTiernan | 1951-01-08 | | 4 | Rian Johnson | 1973-12-17 | +----+----------------+------------+ 

Jeder dieser Regisseure hat einen oder mehrere Filme, die mit ihm verbunden sind: Wie könnten wir sie repräsentieren ? Wir können keine Informationen über die Filme in dieser Tabelle hinzufügen: Dies würde bedeuten, viele wiederholte Daten zu haben: Jedes Mal, wenn wir einen Film hinzufügen. Wir müssen eine dedizierte Tabelle erstellen, um Filmeinformationen zu hosten, und gleichzeitig müssen wir in der Lage sein, eine Referenz zwischen ihm und seinem Regisseur zu erstellen. Das ist, was fremde Schlüssel sind für:

Mariadb [Movie_Store]> Tabellentitel erstellen ( -> ID Smallint (1) Unsigned Not Null Auto_increment, -> Name Varchar (35) NICHT NULL, -> RAVE_DATE DATUM NICHT NULL, -> Genre Varchar (10), nicht Null, -> Director_id Smallint (1) nicht signiert nicht null, -> Primärschlüssel (ID), -> Fremd Key (Director_id) Referenzen Director (ID)); 

Wir haben die Tabelle wie zuvor erstellt, einen Primärschlüssel definiert und einen Fremdschlüsselbeschränkung hinzuge. So ermöglichen wir eine Beziehung zwischen zwei Tabellen: Grundsätzlich stellen wir auf, dass der Wert der Spalte Director_ID für eine Zeile in der Spalte ID der Spalte der Director -Tabelle entsprechen muss (was eindeutig ist, da es die ist, da es die ist TABLE -Primärschlüssel). Mit anderen Worten, jeder Titel muss einen Verweis auf einen vorhandenen Direktor in unserer Datenbank haben, andernfalls wird ein Fehler ausgelöst: Dies gewährleistet die Konsistenz.

Fügen wir einige Titel in unsere Tabelle ein:

Mariadb [Movie_Store]> In Titel ('Name', 'Release_date', 'Genre', 'Director_id') Werte-> ('Night of the Living Dead', '1968-10-01', 'Horror', 2, 2 einfügen. ),-> ('Revenge of the Sith', '2005-05-19', 'Space Opera', 1),-> ('Die Hard', '1988-07-15', 'Action', 3) ; 

Das ist es, wir haben einen Titel. Zuerst haben wir dieses Meisterwerk eines Films eingefügt, der "Night of the Living Dead" unter der Regie von George Romero ist: Beobachten Sie, dass die 2 In der Spalte Director_ID entspricht die ID von George Romero in der Tabelle Director.

Mit demselben Prinzip haben wir einen Film von George Lucas (ID 1 in Regisseur Table), "Revenge of the Sith" und "Die Hard", einen berühmten Actionfilm unter der Regie von John McTiernan (ID 3 in Regisseur Table), eingefügt. Im Moment haben wir keine Filme von Rian Johnson: Es gibt einen Grund dafür (abgesehen von der Tatsache, dass ich von den letzten Jedi enttäuscht war), und wir werden es später sehen. Nachdem wir eine sehr grundlegende Datenbankstruktur einrichten, können wir darüber sprechen schließt sich an.

Wie viele Arten von Join?

Unterschiedliche Namen werden verwendet, um auf die gleiche Art von Verbindungen zu verweisen, aber im Grunde haben wir innere Und äußere schließt sich an. Erstere werden auch genannt Crosded Jungen oder einfach schließt sich an (Sie sind Synonyme in MySQL - Mariadb). Die letztere Kategorie umfasst links Und Rechts schließt sich an.

Innere schließt sich an

Eine innere Verbindung lasst uns Zeilen in einer Tabelle mit Reihen in einer anderen abgleichen. Diese Assoziation kann auf der Beziehung zwischen den beiden Tabellen basieren oder unabhängig davon erfolgen: In diesem Fall werden alle Zeilen einer Tabelle mit allen Reihen des anderen verbunden, wodurch das produziert wird, was sie genannt wird kartesisches Produkt. Dies hat in unserem Beispiel nicht viel Sinn, aber wir können es demonstrieren:

Mariadb [Movie_Store]> SELECT * vom Regisseur Join Title; +----+----------------+------------+----+--------- ------------------+--------------+------------+------ ----------+ | id | Name | Geburtsdatum | id | Name | Release_date | Genre | Director_id | +----+----------------+------------+----+--------- ------------------+--------------+------------+------ ----------+ | 1 | George Lucas | 1944-05-14 | 1 | Nacht der lebenden Toten | 1968-10-01 | Horror | 2 | | 1 | George Lucas | 1944-05-14 | 2 | Rache des Sith | 2005-05-19 | Space Oper | 1 | | 1 | George Lucas | 1944-05-14 | 3 | Stirbend | 1988-07-15 | Aktion | 3 | | 2 | George Romero | 1940-02-04 | 1 | Nacht der lebenden Toten | 1968-10-01 | Horror | 2 | | 2 | George Romero | 1940-02-04 | 2 | Rache des Sith | 2005-05-19 | Space Oper | 1 | | 2 | George Romero | 1940-02-04 | 3 | Stirbend | 1988-07-15 | Aktion | 3 | | 3 | John McTiernan | 1951-01-08 | 1 | Nacht der lebenden Toten | 1968-10-01 | Horror | 2 | | 3 | John McTiernan | 1951-01-08 | 2 | Rache des Sith | 2005-05-19 | Space Oper | 1 | | 3 | John McTiernan | 1951-01-08 | 3 | Stirbend | 1988-07-15 | Aktion | 3 | | 4 | Rian Johnson | 1973-12-17 | 1 | Nacht der lebenden Toten | 1968-10-01 | Horror | 2 | | 4 | Rian Johnson | 1973-12-17 | 2 | Rache des Sith | 2005-05-19 | Space Oper | 1 | | 4 | Rian Johnson | 1973-12-17 | 3 | Stirbend | 1988-07-15 | Aktion | 3 | +----+----------------+------------+----+--------------------------+--------------+------------+-------------+ 

Wie Sie sehen können, wurde jede Zeile einer Tabelle mit jeder Zeile der anderen kombiniert, wobei 12 Zeilen erzeugt werden.

Lassen Sie uns nun einen anderen Anwendungsfall für einen Join sehen. Sagen Sie, wir möchten unsere Datenbank inspizieren, um alle von George Lucas geführten Filme zu überprüfen, die wir im Laden haben. Um diese Aufgabe zu erledigen, müssen wir die Verbindung mit a einschränken AN Klausel, damit sie auf der Beziehung zwischen Titeln und ihrem Regisseur basiert:

Mariadb [Movie_Store]> Direktor auswählen.nenne den Titel.Name als Movie_title vom Regisseur -> Treten Sie den Titel auf dem Regisseur bei.ID = Titel.Director_id -> Wo Director.name = "George Lucas" 

Hier ist das Ergebnis der obigen Abfrage:

+--------------+---------------------+ | Name | Movie_title | +--------------+----------------------+| George Lucas | Rache des Sith | +--------------+---------------------+ 

Mit einem eingeschränkten Join, der auf der Beziehung zwischen den beiden Tabellen basiert, stellten wir fest, dass wir nur einen Titel von George Lucas im Laden haben: Revenge of the Sith. Wir haben nicht nur den Join auf der Basis der Beziehung zwischen den beiden Tabellen eingeschränkt, sondern wir haben die Abfrage auch in die von Lucas geführten Filme beschränkt WO Stellungnahme. Wenn wir es weggelassen hätten, hätte die Abfrage eine Tabelle mit dem vorhandenen Regisseur - Filmkorrespondenz erstellt:

+----------------+--------------------------+ | Name | Movie_title | +----------------+----------------------+| George Lucas | Rache des Sith | | George Romero | Nacht der lebenden Toten | | John McTiernan | Stirbend | +----------------+--------------------------+ 

Beachten Sie, dass Rian Johnson nicht in der Abfrage enthalten ist. Warum das passiert? Dies ist ein Merkmal der inneren Zusammenhänge: Sie zeigen nur Zeilen, in denen ein Match in beiden Tischen existiert. Da in der Titeltabelle keine Korrespondenz für Rian Johnson existiert, haben wir keine Ergebnisse für diesen Regisseur.

Außenverbindungen

Die andere Art von Verbindungen, die wir haben, sind die Außenverbindungen. Diese Kategorie ist selbst unterteilt in Links schließt sich an Und Richtig schließt sich an. Was ist der Unterschied zu den inneren Anschlüssen, die wir oben gesehen haben ? Im Gegensatz zu dem, was mit einem inneren Join passiert, zeigt ein äußerer Join Übereinstimmungen, auch wenn eine Korrespondenz in beiden Tabellen nicht vorhanden ist. Wenn es der Fall ist, zeigt es einen Nullwert in den angeforderten Spalten der Tabelle, in der das Spiel nicht vorhanden ist.Dies kann beispielsweise nützlich sein, wenn wir wissen möchten, ob einige Regisseure ohne Filme assoziiert sind. In unserem Fall wissen wir bereits, dass dies der Fall ist, aber wir können es mit einem linken Join überprüfen:

Mariadb [Movie_Store]> Direktor auswählen.nenne den Titel.Name als Movie_title -> vom Regisseur Links Mach dich dem Titel auf dem Titel an.Director_id = Director.Ausweis 

Das Ergebnis der Abfrage:

+----------------+--------------------------+ | Name | Movie_title | +----------------+----------------------+| George Romero | Nacht der lebenden Toten | | George Lucas | Rache des Sith | | John McTiernan | Stirbend | | Rian Johnson | NULL | +----------------+--------------------------+ 

Der einzige Regisseur, der keine Filme in unserem Geschäft hat, ist Rian Johnson. Wenn Sie eine äußere Verbindung verwenden, ist die Reihenfolge, in der wir die Tabellen angeben, wichtig. Zum Beispiel mit a Links Join, Wie oben, als die Zeile aus der linken Tabelle (in diesem Fall Director) keine Übereinstimmung in den Reihen der rechten Tabelle (Titel) hat, ist a NULL Der Wert wird in jeder angeforderten Spalte des letzteren angegeben; Wenn eine Übereinstimmung gefunden wird, wird stattdessen der Wert angezeigt, wie es bei einer inneren Verbindung passiert.

A Right Join funktioniert genauso, der einzige Unterschied besteht darin, dass die Rolle der Tabellen umgekehrt ist. In der rechten Seite verbinden Sie die gesamte Zeile der rechten Tabelle, die in der linken Tabelle nicht übereinstimmt, mit einem Nullwert markiert.

Diese Eigenschaft der Außenverbindungen ist sehr nützlich, aber es gibt Fälle, in denen ein wenig Verwirrung auftreten kann, insbesondere wenn eine Tabelle in einigen seiner Spalten einen Nullwert hat.

Verwandte Linux -Tutorials:

• Installieren Sie MySQL auf Ubuntu 20.04 LTS Linux
• Dinge zu installieren auf Ubuntu 20.04
• So installieren Sie MySQL auf Almalinux
• So ändern Sie Mariadb -Benutzerkennwort
• Einführung in MySQL -Speichermotoren
• GUI -Anwendungen für grafische Benutzeroberflächen für die Verwaltung…
• Ubuntu 20.04 WordPress mit Apache -Installation
• Eine Einführung in Linux -Automatisierung, Tools und Techniken
• OpenLiteSpeed ​​WordPress Installation
• Ampache Raspberry Pi Installation