SQL-Tutorial für Anfänger

In diesem SQL-Tutorial für Anfänger erstellen Sie Ihre eigene Datenbank, fügen Daten in diese Datenbank ein und führen dann Abfragen für diese Datenbank aus.

Mit diesem SQL-Tutorial können Sie im Handumdrehen SQL-Abfragen ausführen!

SQL-Beispiel

Hier ist ein Beispiel für eine SQL-Anweisung:

SELECT * 
FROM Pets;

Dies ist ein perfektes Beispiel dafür, wie einfach es sein kann, SQL zu schreiben. Diese einfache SQL-Anweisung leistet tatsächlich viel. Es gibt die gesamte Tabelle zurück. Es gibt alle Spalten und alle Zeilen aus der Tabelle mit dem Namen Pets zurück .

Das Sternchen (* ) ist ein Platzhalterzeichen, was „alle Spalten“ bedeutet. Es ist eine schnelle und einfache Möglichkeit, alle Spalten abzurufen, ohne sie alle eingeben zu müssen.

Das ist eines der schönen Dinge an SQL. Die einfachsten SQL-Abfragen sind normalerweise die mächtigsten. Wenn wir weniger Daten zurückgeben wollten, müssten wir eigentlich mehr schreiben .

Zum Beispiel, wenn wir nur Haustiere namens Fetch wollten , würden wir ein WHERE hinzufügen Klausel, die dieses Erfordernis vorsah.

So:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

Das WHERE -Klausel filtert unsere Abfrage nur auf die Zeilen, in denen der PetName Spalte hat den Wert Fetch .

Diese Abfrage geht davon aus, dass es eine Spalte namens PetName gibt und eine Tabelle namens Pets in der Datenbank.

In diesem SQL-Tutorial zeige ich Ihnen, wie Sie eine solche Datenbank mit SQL erstellen.

Ich zeige Ihnen auch, wie Sie Daten in diese Datenbank einfügen, Daten aktualisieren, Daten löschen und Abfragen dafür ausführen.

Was ist SQL?

SQL ist ein Akronym für Structured Query Language.

SQL ist die Standardabfragesprache für die Arbeit mit relationalen Datenbanken.

SQL wird von allen wichtigen Managementsystemen für relationale Datenbanken (RDBMS) verwendet, darunter:

• Microsoft Access
• SQL-Server
• Orakel
• PostgreSQL
• MySQL
• SQLite

Was kann ich mit SQL machen?

Sie können SQL verwenden, um Abfragen für eine Datenbank auszuführen, Datensätze einzufügen, Datensätze zu aktualisieren und Datensätze zu löschen. Sie können auch neue Datenbankobjekte wie Datenbanken und Tabellen erstellen. Sie können auch Datenbankverwaltungsaufgaben ausführen, wie z. B. das Erstellen von Anmeldungen, automatisierten Jobs, Datenbanksicherungen und vielem mehr.

Selbst wenn Sie Dinge mit einer grafischen Benutzeroberfläche (GUI) erledigen, wird Ihr Datenbankmanagementsystem (DBMS) mit ziemlicher Sicherheit hinter den Kulissen SQL verwenden, um diese Aufgabe auszuführen.

Zum Beispiel, wenn Sie eine Datenbank erstellen, indem Sie auf Datenbank erstellen klicken und geben Sie die Details der neuen Datenbank in ein Dialogfeld ein, nachdem Sie auf OK geklickt haben oder Erstellen oder was auch immer auf der Schaltfläche steht, Ihr Datenbanksystem verwendet die SQL CREATE DATABASE Anweisung, fortzufahren und die Datenbank wie angegeben zu erstellen.

Dasselbe gilt für andere Aufgaben, wie das Ausführen von Abfragen, das Einfügen von Daten usw.

Mit SQL können Sie auch fortgeschrittenere Aktionen ausführen, wie z. B. das Erstellen von gespeicherten Prozeduren (eigenständige Skripts), Ansichten (vorgefertigte Abfragen) und das Festlegen von Berechtigungen für Datenbankobjekte (wie Tabellen, gespeicherte Prozeduren und Ansichten).

Das heißt, Sie müssen nicht alle fortgeschrittenen Dinge lernen, um mit SQL zu beginnen. Das Gute an SQL ist, dass einige der häufigsten Aufgaben am einfachsten zu schreiben sind.

SQL-Standard

SQL wurde 1986 in ANSI X3.135 standardisiert und innerhalb weniger Monate von ISO als ISO 9075-1987 übernommen. Der internationale Standard (jetzt ISO/IEC 9075) wurde seitdem regelmäßig überarbeitet und besteht derzeit aus 9 Teilen.

Die meisten großen Datenbankanbieter neigen dazu, sich an den SQL-Standard zu halten. Das Gute daran ist, dass Sie nicht jedes Mal eine neue Abfragesprache lernen müssen, wenn Sie ein neues DBMS lernen.

In der Praxis gibt es jedoch Unterschiede zwischen der Implementierung des SQL-Standards durch die einzelnen Datenbankanbieter. Daher funktioniert Code, den Sie in einem DBMS schreiben, möglicherweise nicht immer in einem anderen, ohne dass Änderungen erforderlich sind.

Die gute Nachricht ist, dass alle großen DBMS die häufigsten Aufgaben im Allgemeinen auf die gleiche Weise unterstützen.

SQL-Aussprache

SQL wird normalerweise auf eine von zwei Arten ausgesprochen:

• “ess-que-el ” (d. h. jeden Buchstaben buchstabieren)
• „Fortsetzung “ (wie in der ursprünglichen Schreibweise/Aussprache).

Siehe Wird es S-Q-L ausgesprochen oder Sequel, wenn Sie sich fragen, warum.

Was benötige ich für dieses SQL-Tutorial?

Um wirklich von diesem SQL-Tutorial zu profitieren, sollten Sie den Beispielen folgen. Das bedeutet, dass Sie irgendwo die SQL-Abfragen eingeben müssen. Sie müssen so etwas haben:

Wenn Sie SQL-Abfragen ausführen möchten, benötigen Sie:

• Ein installiertes RDBMS (wie SQL Server, MySQL, PostgreSQL, SQLite usw.).
• Ein Datenbanktool, mit dem Sie SQL-Abfragen für dieses RDBMS ausführen können (z. B. MySQL WorkBench, Azure Data Studio (im Bild), DBeaver und SSMS).

Wenn Sie bereits eine von beiden installiert haben, großartig! Sie können mit dem Tutorial fortfahren.

Wenn Sie diese nicht installiert haben, lesen Sie Was muss ich tun, um SQL auszuführen? für Anweisungen zur Installation eines RDBMS und seines relevanten Datenbankverwaltungstools, bevor Sie zu diesem SQL-Lernprogramm zurückkehren.

Datenbank erstellen

Sobald Sie Ihr RDBMS und das entsprechende Datenbanktool installiert haben, können Sie eine Datenbank erstellen:

CREATE DATABASE PetHotel;

Erledigt!

Diese Anweisung hat tatsächlich eine Datenbank erstellt. Eine leere Datenbank, aber trotzdem eine Datenbank.

Diese Datenbank enthält die Tabellen und Daten, die in diesem SQL-Lernprogramm verwendet werden. Wenn wir eine Tabelle erstellen oder Daten einfügen, tun wir dies innerhalb dieser Datenbank.

Ich sollte erwähnen, dass SQLite eine andere Syntax zum Erstellen von Datenbanken verwendet. Wenn Sie SQLite verwenden, erfahren Sie hier, wie Sie eine Datenbank in SQLite erstellen.

Mit der Datenbank verbinden

Bevor Sie mit dem Erstellen von Tabellen, dem Einfügen von Daten usw. beginnen, müssen Sie sicherstellen, dass Sie sich in der richtigen Datenbank befinden. Das Erstellen einer Datenbank (wie wir es gerade getan haben) verbindet Sie nicht unbedingt mit dieser Datenbank.

In vielen DBMS (wie SQL Server , MySQL und MariaDB ), können wir folgendermaßen auf die angegebene Datenbank umschalten:

USE PetHotel;

Das macht PetHotel die aktuelle Datenbank.

In SQLite , befinden Sie sich wahrscheinlich bereits in der Datenbank, nachdem Sie sie erstellt haben. Wenn nicht, können Sie die Datenbank anhängen (die sie auch erstellt, wenn sie noch nicht existiert):

ATTACH DATABASE 'PetHotel.db' AS Pets;

In PostgreSQL , wenn Sie das psql-Tool verwenden, können Sie Folgendes verwenden:

\connect PetHotel

Oder die gekürzte Version:

\c PetHotel

Ich sollte erwähnen, dass der Prozess der Erstellung und Verbindung mit Datenbanken zwischen DBMSs sehr unterschiedlich sein kann.

Glücklicherweise können Sie mit den meisten GUI-Tools eine Verbindung zu einer Datenbank herstellen, indem Sie entweder auf die Datenbank doppelklicken oder mit der rechten Maustaste auf den Datenbanknamen klicken und im Kontextmenü eine neue Abfrage-Registerkarte auswählen. Wenn Sie bei diesem Schritt stecken bleiben, verwenden Sie einfach die GUI, um Ihre DB zu erstellen und/oder sich mit ihr zu verbinden.

Erstelle eine Tabelle

Nachdem Sie sich nun mit der richtigen Datenbank verbunden haben, können Sie fortfahren und einige Tabellen erstellen.

Um eine Tabelle in SQL zu erstellen, verwenden Sie CREATE TABLE Aussage.

Wenn Sie eine Tabelle erstellen, müssen Sie angeben, welche Spalten in der Tabelle enthalten sein werden, sowie deren Datentypen. Sie können auch andere Details angeben, aber lassen Sie uns nicht vorgreifen.

Lassen Sie uns eine Tabelle erstellen:

CREATE TABLE PetTypes
(
    PetTypeId   int NOT NULL PRIMARY KEY,
    PetType     varchar(60) NOT NULL
);

In diesem Fall erstellen wir eine Tabelle namens PetTypes . Das wissen wir, weil der Tabellenname unmittelbar nach CREATE TABLE kommt Bit.

Danach kommt eine Liste von Spalten, eingeschlossen in Klammern.

Die obige Tabelle enthält die folgenden Spalten:

• PetIdId
• PetType

Auf jede Spalte folgt ihr Datentyp:

• int bedeutet, dass diese Spalte ganze Zahlen akzeptiert. Soweit mir bekannt ist, unterstützen die meisten großen DBMS das Deklarieren von Spalten als int . Wenn Sie Probleme haben, versuchen Sie es mit integer .
• varchar(60) bedeutet, dass diese Spalte Zeichenfolgen mit einer Länge von bis zu 60 Zeichen akzeptiert. varchar Spalten sind Zeichenfolgen variabler Länge. Ein weiterer String-Datentyp ist char (was eine Zeichenfolge fester Länge ist). Wenn Sie Probleme haben, eine Spalte als varchar(60) zu definieren , versuchen Sie es mit char(60) .

NOT NULL Einschränkungen

In diesem Beispiel sind beide Spalten mit NOT NULL definiert Einschränkungen. Der NOT NULL Einschränkung bedeutet, dass diese Spalte nicht leer sein darf. Wenn eine neue Zeile eingefügt wird, alle NOT NULL Spalten müssen einen Wert enthalten. Andere Spalten können leer bleiben, wenn für diese Spalten keine Daten vorhanden sind.

Wenn NULL Werte in der Spalte erlaubt sind, können Sie entweder NOT NULL weglassen Teil oder als NULL deklarieren (bedeutet NULL Werte sind in dieser Spalte erlaubt).

Einige DBMS (z. B. DB2) unterstützen den NULL nicht Schlüsselwort sowieso, und daher müssen Sie es weglassen, wenn Sie mit solchen DBMSs arbeiten.

Primärschlüssel

Wir haben auch die PetTypeId erstellt Spalte der Primärschlüssel. Der Primärschlüssel ist eine oder mehrere Spalten, die jede Zeile in der Tabelle eindeutig identifiziert. Sie geben Ihre ausgewählte(n) Spalte(n) als Primärschlüssel an, indem Sie eine Primärschlüsseleinschränkung verwenden. Sie können dies im CREATE TABLE tun -Anweisung (wie wir es hier getan haben), oder Sie können eine später mit einem ALTER TABLE hinzufügen Erklärung.

Primärschlüssel müssen eindeutige Werte enthalten. Das heißt, für jede Zeile in dieser Tabelle muss der Wert in der/den Primärschlüsselspalte(n) in jeder Zeile unterschiedlich sein. Dies kann so einfach sein wie aufsteigende Zahlen (wie 1, 2, 3 usw.) oder ein Produktcode (wie pr4650, pr2784, pr5981 usw.).

Außerdem müssen Primärschlüssel einen Wert enthalten. Er darf nicht NULL sein .

Obwohl Primärschlüssel nicht erforderlich sind, gilt es im Allgemeinen als bewährte Methode, einen Primärschlüssel für jede Tabelle zu definieren.

Weitere Tabellen erstellen

Lassen Sie uns zwei weitere Tabellen erstellen:

CREATE TABLE Owners
(
    OwnerId     int NOT NULL PRIMARY KEY,
    FirstName   varchar(60) NOT NULL,
    LastName    varchar(60) NOT NULL,
    Phone       varchar(20) NOT NULL,
    Email       varchar(254)
);

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL REFERENCES PetTypes (PetTypeId),
    OwnerId     int NOT NULL REFERENCES Owners (OwnerId),
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

Diese beiden Tabellen sind der ersten ähnlich, außer dass sie mehr Zeilen und ein paar zusätzliche Teile haben, die ich weiter unten erklären werde.

Wenn Sie interessiert sind, sehen Sie sich SQL CREATE TABLE für Anfänger an, um ein paar weitere einfache Beispiele zum Erstellen von Tabellen in SQL zu erhalten.

Beziehungen

Als wir unsere Pets erstellt haben Tabelle haben wir tatsächlich eine Beziehung zwischen den drei Tabellen erstellt.

Diese Beziehung wird im folgenden Diagramm dargestellt.

Datenbankbeziehungen sind ein entscheidender Teil von SQL. Beziehungen ermöglichen es uns, mehrere Tabellen nach verwandten Daten abzufragen und genaue und konsistente Ergebnisse zu erhalten.

In unserem Fall möchten wir in der Lage sein, nach Haustieren nach Besitzer oder nach Haustiertyp usw. zu suchen. Und wir möchten, dass unsere Ergebnisse genau und konsistent sind.

Um dies zu erreichen, müssen wir darauf bestehen, dass alle Haustiere zusammen mit ihrem Besitzer und Haustiertyp eingetragen werden. Daher müssen wir sicherstellen, dass jedes Mal, wenn ein neues Haustier zu den Pets hinzugefügt wird In der Tabelle Owners gibt es bereits einen entsprechenden Eigentümer Tabelle und einen entsprechenden Pet-Typ in den PetTypes Tisch.

Grundsätzlich lauten unsere Anforderungen wie folgt:

• Jeder Wert in Pets.PetTypeId Spalte muss mit einem Wert in PetTypes.PetTypeId übereinstimmen Spalte.
• Jeder Wert in Pets.OwnerId Spalte muss mit einem Wert in Owners.OwnerId übereinstimmen Spalte.

Wir können die oben genannten Anforderungen sicherstellen, indem wir eine Fremdschlüsseleinschränkung für die entsprechenden Spalten erstellen. Ein Fremdschlüssel Einschränkung wird verwendet, um anzugeben, dass eine bestimmte Spalte auf den Primärschlüssel einer anderen Tabelle verweist.

Der obige Code hat tatsächlich zwei Fremdschlüsseleinschränkungen für Pets erstellt Tabelle.

Beachten Sie, dass die PetTypeId und OwnerId Spalten haben zusätzlichen Code, der mit REFERENCES... beginnt . Das sind die Teile, die die beiden Fremdschlüssel erstellt haben.

Als wir die Pets erstellt haben Tabelle, ihre PetTypeId Spalte hat ein Bit, das REFERENCES PetTypes (PetTypeId) lautet . Das bedeutet, dass die Pets.PetTypeId Spalte verweist auf die PetTypeId Spalte in der PetTypes Tabelle.

Dasselbe gilt für die OwnerId Säule. Es verweist auf die OwnerId Spalte der Owners Tabelle.

In den meisten DBMSs können Fremdschlüssel auch für eine vorhandene Tabelle erstellt werden, indem der ALTER TABLE verwendet wird Aussage, aber darauf gehen wir hier nicht ein. Weitere Informationen dazu finden Sie unter So erstellen Sie eine Beziehung in SQL.

Wie auch immer, unsere Fremdschlüssel wurden erstellt. Jetzt immer dann, wenn jemand ein neues Haustier in die Pets einfügt Tabelle, die PetTypeId und OwnerId Werte müssen einen entsprechenden Wert in den PetTypes haben und Owners Tabellen bzw. Wenn einer von ihnen dies nicht tut, gibt die Datenbank einen Fehler zurück.

Dies ist der Vorteil von Fremdschlüsseln. Es hilft zu verhindern, dass falsche Daten eingegeben werden. Es hilft, die Datenintegrität und insbesondere die referenzielle Integrität aufrechtzuerhalten.

Beschränkungen prüfen

Eine Check-Einschränkung ist ein weiterer Einschränkungstyp, den Sie kennen sollten. Eine Check-Einschränkung prüft Daten, bevor sie in die Datenbank gelangen. Wenn für eine Tabelle eine Check-Einschränkung aktiviert ist, können Daten nur in die Tabelle gelangen, wenn sie diese Einschränkung nicht verletzen. Daten, die gegen die Einschränkung verstoßen, können nicht in die Tabelle aufgenommen werden.

Beispielsweise können Sie eine Check-Einschränkung für einen Price erstellen Spalte, um sicherzustellen, dass nur Werte akzeptiert werden, die größer als Null sind. Oder wir könnten eine Check-Einschränkung auf unsere Pets anwenden Tabelle, um sicherzustellen, dass das DOB Spalte liegt nicht in der Zukunft.

Ein Beispiel finden Sie unter Was ist eine CHECK-Einschränkung?

Leerzeichen

Sie haben vielleicht bemerkt, dass meine Beispiele Leerzeichen enthalten. Zum Beispiel habe ich den Code über mehrere Zeilen verteilt und ich habe Tabulatoren verwendet, um die Datentypen einzurücken usw.

Dies ist in SQL vollkommen gültig. Sie können dies sicher tun und es wird das Ergebnis nicht beeinflussen. SQL erlaubt es Ihnen, Ihren Code auf mehrere Zeilen zu verteilen, wenn Sie möchten, und es erlaubt Ihnen, mehrere Leerzeichen oder Tabulatoren zu verwenden, um die Lesbarkeit zu verbessern.

Kommentare

Sie können auch Kommentare in Ihren Code einfügen. Kommentare können nützlich sein, wenn Sie anfangen, längere SQL-Skripts zu schreiben. Wenn ein Skript ziemlich lang wird, können Kommentare es einfacher machen, schnell zu erkennen, was jeder Teil tut.

Inline-Kommentare

Sie können Inline-Kommentare erstellen, indem Sie Ihrem Kommentar zwei Bindestriche voranstellen (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

In diesem Beispiel werden beide Abfragen problemlos ausgeführt. Die Kommentare werden vom DBMS ignoriert.

Mehrzeilige Kommentare

Sie können Kommentare über mehrere Zeilen verteilen, indem Sie den Kommentar mit /* umgeben und */ :

/*
This is a longer comment so
it's spread across multiple lines
*/
SELECT * FROM Pets;

In diesem Beispiel werden beide Abfragen problemlos ausgeführt. Die Kommentare werden vom DBMS ignoriert.

MySQL

Wenn Sie MySQL verwenden, können Sie auch das Nummernzeichen/Hash-Zeichen (# ) für einzeilige Kommentare.

# This is a comment
SELECT * FROM Pets;

Code auskommentieren

Ein weiterer toller Vorteil von Kommentaren ist, dass Sie auskommentieren können Code. Wenn Sie beispielsweise ein langes SQL-Skript haben, das viele Aufgaben erledigt, aber nur einen oder zwei Teile davon ausführen möchten, können Sie es auskommentieren der Rest des Skripts.

Hier ist ein Beispiel:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

In diesem Fall das erste SELECT -Anweisung wurde auskommentiert, also nur die zweite SELECT Anweisung wird ausgeführt.

Sie können für diese Technik auch mehrzeilige Kommentare verwenden.

Daten einfügen

Nachdem wir nun drei Tabellen und die entsprechenden Fremdschlüssel erstellt haben, können wir fortfahren und Daten hinzufügen.

Die gebräuchlichste Methode zum Einfügen von Daten in SQL ist das INSERT Erklärung. Das geht ungefähr so:

INSERT INTO MyTable( Column1, Column2, Column3, ... )
VALUES( Value1, Value2, Value3, ... );

Sie ersetzen einfach MyTable mit dem Namen der Tabelle, in die Sie Daten einfügen. Ebenso ersetzen Sie Column1 , etc mit den Spaltennamen und Value1 , etc mit den Werten, die in diese Spalten gehen.

Zum Beispiel könnten wir dies tun:

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Jeder Wert befindet sich in derselben Reihenfolge, in der die Spalte angegeben ist.

Beachten Sie, dass die Spaltennamen mit den Namen übereinstimmen, die wir beim Erstellen der Tabelle verwendet haben.

Sie können die Spaltennamen weglassen, wenn Sie Daten in alle Spalten einfügen. Wir könnten also das obige Beispiel so ändern, dass es so aussieht:

INSERT INTO Pets
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Für dieses Tutorial fügen wir einige weitere Zeilen hinzu, also fügen wir weitere INSERT INTO hinzu Anweisungen – eine für jede Zeile, die wir einfügen möchten.

Also lass uns weitermachen und unsere Tabellen füllen.

INSERT INTO Owners( OwnerId, FirstName, LastName, Phone, Email )
VALUES( 1, 'Homer', 'Connery', '(308) 555-0100', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone, Email)
VALUES( 2, 'Bart', 'Pitt', '(231) 465-3497', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 3, 'Nancy', 'Simpson', '(489) 591-0408' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 4, 'Boris', 'Trump', '(349) 611-8908' ); 

INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 1, 'Bird' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 2, 'Cat' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 3, 'Dog' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 4, 'Rabbit' );

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-11-20' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 2, 3, 3, 'Fetch', '2019-08-16' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 3, 2, 2, 'Scratch', '2018-10-01' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 4, 3, 3, 'Wag', '2020-03-15' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 5, 1, 1, 'Tweet', '2020-11-28' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 6, 3, 4, 'Fluffy', '2020-09-17' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 7, 3, 2, 'Bark' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 8, 2, 4, 'Meow' );

Beachten Sie, dass wir die Pets ausgefüllt haben Tisch zuletzt. Dafür gibt es einen Grund.

Wenn wir versucht hätten, Daten in die Pets einzufügen Tabelle vor dem Füllen der anderen beiden, hätten wir aufgrund unserer Fremdschlüsseleinschränkung einen Fehler erhalten. Und das aus gutem Grund. Schließlich hätten wir versucht, Werte in die Fremdschlüsselspalten einzufügen, die in den Primärschlüsselspalten der anderen Tabellen noch nicht vorhanden waren. Das ist ein großes Nein, wenn es um Fremdschlüssel geht.

Also durch Ausfüllen der Owners und PetTypes Tabellen haben wir sichergestellt, dass die entsprechenden Werte bereits in den Primärschlüsselspalten vorhanden waren, bevor wir die Fremdschlüsselspalten in den Pets gefüllt haben Tabelle.

Weitere Beispiele zum Einfügen von Daten in Tabellen finden Sie unter SQL INSERT für Anfänger.

Prüfen Sie unsere Daten

Puh! Endlich können wir damit beginnen, Abfragen für unsere Datenbank auszuführen.

Lassen Sie uns die Daten in allen unseren Tabellen überprüfen.

SELECT * FROM Pets;
SELECT * FROM PetTypes;
SELECT * FROM Owners;

Ergebnis:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)
+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
+-----------+-------------+------------+----------------+-------------------+
(4 rows affected)

Großartig, es sieht also so aus, als ob die Daten erfolgreich eingefügt wurden.

Spezielle Spalten auswählen

Es wird im Allgemeinen als schlechte Praxis angesehen, alle Zeilen und alle Spalten aus einer Tabelle auszuwählen (wie wir es im vorherigen Beispiel getan haben), es sei denn, Sie müssen dies wirklich tun. Dies kann sich auf die Leistung Ihres Datenbankservers auswirken, insbesondere wenn die Tabelle viele Zeilen enthält.

Es ist kein Problem, wenn Sie kleine Datensätze wie wir hier verwenden, oder wenn Sie sich in einer Entwicklungsumgebung oder ähnlichem befinden. Andernfalls ist es normalerweise besser, nur die gewünschten Spalten auszuwählen.

Wenn wir also die IDs, Namen und Geburtsdaten aller Haustiere haben wollten, könnten wir Folgendes tun:

SELECT PetId, PetName, DOB 
FROM Pets; 

Ergebnis:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 3       | Scratch   | 2018-10-01 |
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
| 8       | Meow      | NULL       |
+---------+-----------+------------+

Wenn wir die IDs und das Geburtsdatum aller Haustiere namens Fluffy haben wollten, könnten wir dies verwenden:

SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy';

Ergebnis:

+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

Sie können auch den SELECT verwenden -Anweisung, um keine Tabellendaten zurückzugeben. Das heißt, es kann Daten zurückgeben, die nicht in einer Tabelle gespeichert sind. Siehe SQL SELECT Erklärung für Anfänger, um ein Beispiel zu sehen.

Sortierung

SQL stellt den ORDER BY bereit Klausel, die es uns ermöglicht, Daten zu sortieren.

Wir können einen ORDER BY hinzufügen -Klausel zu unserem vorherigen Beispiel hinzu, sodass die Haustiere nach ihren Namen sortiert werden:

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName ASC;

Ergebnis:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 7       | Bark      | NULL       |
| 2       | Fetch     | 2019-08-16 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 8       | Meow      | NULL       |
| 3       | Scratch   | 2018-10-01 |
| 5       | Tweet     | 2020-11-28 |
| 4       | Wag       | 2020-03-15 |
+---------+-----------+------------+

Der ASC Teil bedeutet aufsteigend . Wenn Sie den ORDER BY verwenden -Klausel, ist sie standardmäßig aufsteigend, sodass Sie ASC weglassen können Teil, wenn Sie möchten.

Um es absteigend zu sortieren verwenden Sie DESC .

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC;

Ergebnis:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Sie können die Ergebnisse auch nach mehreren Spalten sortieren. Es wird nach der ersten angegebenen Spalte sortiert, und wenn es Duplikate in dieser Spalte gibt, werden diese Duplikate nach der zweiten angegebenen Spalte sortiert, und so weiter.

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC, DOB ASC;

Ergebnis:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 6       | Fluffy    | 2020-09-17 |
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Sehen Sie, wie die beiden Fluffys ihre Position getauscht haben.

Wenn Sie den ORDER BY nicht verwenden -Klausel gibt es keine Garantie, in welcher Reihenfolge Ihre Ergebnisse angezeigt werden. Auch wenn es aussehen kann wie Ihre Datenbank die Ergebnisse nach einer bestimmten Spalte sortiert, ist dies möglicherweise nicht der Fall. Generell ohne ORDER BY -Klausel werden die Daten in der Reihenfolge sortiert, in der sie in die Tabelle geladen wurden. Wenn jedoch Zeilen gelöscht oder aktualisiert wurden, wird die Reihenfolge davon beeinflusst, wie das DBMS den zurückgewonnenen Speicherplatz wiederverwendet.

Verlassen Sie sich daher nicht darauf, dass das DBMS die Ergebnisse in einer sinnvollen Reihenfolge sortiert.

Fazit:Wenn Sie möchten, dass Ihre Ergebnisse sortiert werden, verwenden Sie ORDER BY .

Siehe SQL ORDER BY Abschnitt für Anfänger für weitere Beispiele.

Zeile in einer Ergebnismenge zählen

Sie können den COUNT() verwenden Aggregatfunktion zum Zählen der Zeilen, die in einer Abfrage zurückgegeben werden.

SELECT COUNT(*) AS Count
FROM Pets;

Ergebnis:

+---------+
| Count   |
|---------|
| 8       |
+---------+

Dies sagt uns, dass es 8 Zeilen in der Tabelle gibt. Das wissen wir, weil wir alle Zeilen und alle Spalten ausgewählt haben.

Sie können COUNT() verwenden bei jeder Abfrage, zum Beispiel Abfragen, die ein WHERE verwenden -Klausel, um die Ergebnisse zu filtern.

Sie können auch eine bestimmte zu zählende Spalte angeben. Der COUNT() Funktion zählt nur Nicht-NULL Ergebnisse, also wenn Sie eine Spalte angeben, die NULL enthält Werte, diese Werte werden nicht gezählt.

Hier ist ein Beispiel, um zu demonstrieren, was ich meine.

SELECT COUNT(DOB) AS Count
FROM Pets;

Ergebnis:

+---------+
| Count   |
|---------|
| 6       |
+---------+
Warning: Null value is eliminated by an aggregate or other SET operation.

Sie erinnern sich vielleicht, dass die Pets Tabelle enthält zwei NULL Werte im DOB Spalte (zwei Haustiere haben ihr Geburtsdatum nicht angegeben), also COUNT(DOB) gibt 6 statt 8 zurück, wenn wir COUNT(*) verwendet haben . Der Grund COUNT(*) alle Zeilen zurückgegeben hat, liegt daran, dass diese beiden Zeilen es taten haben Daten in den anderen Spalten.

In meinem Beispiel hat mein DBMS auch eine Warnung dazu zurückgegeben. Abhängig von Ihrem DBMS und Ihrer spezifischen Konfiguration erhalten Sie möglicherweise eine Warnung oder auch nicht.

Siehe SQL COUNT für Anfänger für weitere Beispiele.

Andere Aggregatfunktionen umfassen:AVG() , SUM() , MIN() , und MAX() .

Gruppieren nach

Eine weitere nützliche Klausel ist GROUP BY Klausel. Das hält ziemlich genau das, was sein Name verspricht. Sie können die Ergebnisse nach einer bestimmten Spalte gruppieren.

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
ORDER BY Count DESC;

Ergebnis:

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
| 1           | 1       |
+-------------+---------+

In diesem Beispiel zählen wir, wie viele Haustiere wir für jeden Haustiertyp haben, und sortieren sie dann in absteigender Reihenfolge (mit der höchsten Zahl ganz oben).

Siehe SQL GROUP BY Abschnitt für Anfänger für weitere Beispiele.

Das HAVING Klausel

Wir können den HAVING verwenden -Klausel, um die Ergebnisse in GROUP BY zu filtern Klausel. Das HAVING -Klausel gibt Zeilen zurück, in denen Aggregatwerte bestimmte Bedingungen erfüllen.

Hier ist ein Beispiel.

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;

Ergebnis:

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
+-------------+---------+

In diesem Fall haben wir nur Daten für die Pet-Typen zurückgegeben, denen mehr als 2 Pets zugeordnet sind.

Siehe SQL HAVING Abschnitt für Anfänger für weitere Beispiele.

Beitreten

In SQL ein Join Hier führen Sie eine Abfrage aus, die Daten aus mehreren Tabellen kombiniert.

Die beiden vorherigen Beispiele sind in Ordnung, aber es wäre besser, wenn sie die tatsächlichen Haustiertypen (z. B. Katze, Hund, Vogel usw.) anstelle der ID (z. B. 1, 2, 3 usw.) zurückgeben würden.

Das einzige Problem sind die Pets Tabelle enthält diese Daten nicht. Diese Daten befinden sich in den PetTypes Tabelle.

Glücklicherweise können wir zwischen diesen beiden Tabellen eine Verbindung herstellen. Hier ist ein Beispiel, das einen LEFT JOIN verwendet :

SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC;

Ergebnis:

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Diese Ergebnismenge ist viel einfacher zu lesen als die vorherigen. Es ist einfacher zu verstehen, wie viele von jedem Haustiertyp in der Tabelle enthalten sind.

Die Syntax verwendet den Join-Typ (in diesem Fall LEFT JOIN ), gefolgt von der ersten (linken) Tabelle, gefolgt von ON , gefolgt von der Join-Bedingung.

Lassen Sie uns einen INNER JOIN verwenden um alle Tiernamen mit ihren jeweiligen Tierarten zurückzugeben.

SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets 
INNER JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId;

Ergebnis:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

Joins eröffnen unsere Optionen wirklich, da wir jetzt Daten aus mehreren Tabellen abrufen und sie so darstellen können, als wäre es eine einzelne Tabelle.

You’ll notice that in the join examples, we qualify our column names with the table names. The reason we do this is to avoid any ambiguity regarding the column column names between the tables. Both tables could have columns of the same name (like in our example), and in such cases, the DBMS won’t know which column you’re referring to. Prefixing the column names with their table names ensures that you’re referencing the right column, and prevents any errors that could result from any ambiguity about which column you’re referring to.

See my SQL Joins Tutorial for more examples and an explanation of the various join types.

Aliases

We can go a step further and assign an alias to each table name and column name.

SELECT 
    p.PetName AS Pet,
    pt.PetType AS "Pet Type"
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Ergebnis:

+---------+------------+
| Pet     | Pet Type   |
|---------+------------|
| Tweet   | Bird       |
| Fluffy  | Cat        |
| Scratch | Cat        |
| Meow    | Cat        |
| Fetch   | Dog        |
| Wag     | Dog        |
| Fluffy  | Dog        |
| Bark    | Dog        |
| NULL    | Rabbit     |
+---------+------------+

This has resulted in new column headers, plus the code is more concise.

An alias allows you to temporarily assign another name to a table or column for the duration of a SELECT Anfrage. This can be particularly useful when tables and/or columns have very long or complex names.

An alias is assigned through the use of the AS keyword, although this keyword is optional, so you can safely omit it. Note that Oracle doesn’t support the AS keyword on table aliases (but it does on column aliases).

In the above example, I’ve included the AS keyword when assigning the column aliases, but omitted it when assigning the table aliases.

An alias name could be anything, but is usually kept short for readability purposes.

In our case, we changed the two tables to p and pt , and the column names to Pet and Pet Type . Note that I surrounded Pet Type in double quotes. I did this, because there’s a space in the name. For aliases without spaces, you don’t need to do this. In SQL Server, you can alternatively use square brackets ([] ) instead of double quotes (although it also supports double quotes).

The practice of using spaces in columns and aliases is generally discouraged, as it can cause all sorts of problems with some client applications.

Note that we still needed to use the full column names when referencing them in the join (after the ON keyword).

Ich sollte darauf hinweisen, dass die Zuweisung eines Alias ​​die Spalte oder Tabelle nicht wirklich umbenennt.

See SQL Alias Explained for more examples.

Updating Data

You can use the UPDATE statement to update data in your tables.

The basic syntax is pretty simple:

UPDATE Owners
SET LastName = 'Stallone'
WHERE OwnerId = 3;

In that example, we update the LastName column to have a new value of Stallone where the OwnerId is 3 .

To update multiple columns, use a comma to separate each column/value pair.

But whatever you do, don’t forget the WHERE clause (unless you actually intend to update every row in the table with the same value).

See SQL UPDATE for Beginners for more examples and a more detailed explanation.

Deleting Data

You can use the DELETE statement to delete data from your tables.

The basic syntax is even more simple than the UPDATE statement:

DELETE FROM Owners
WHERE OwnerId = 5;

Here, we’re deleting owner number 5 from the Owners table.

As with the UPDATE statement, don’t forget the WHERE clause (unless you intend to delete every row in the table ).

See SQL DELETE for Beginners for more examples and a detailed explanation.

Dropping Objects

While we’re on the subject of deleting things, when you delete a database object (such as a table, view, stored procedure, etc), it’s said that you “drop” that object. For example, if you no longer need a table, you “drop it”.

The syntax is extremely simple, and it goes like this:

DROP TABLE Customers;

Those three words completely obliterated a table called Customers . The table and all its data is now gone.

As you can imagine, this can be a very dangerous statement, and should be used with extreme caution.

The same syntax can be used for other object types, except you would replace table with the object type (for example DROP VIEW vPets drops a view called vPets ).

If you try to drop a table that is referenced by a foreign key, you’ll probably get an error. In this case, you’ll need to either drop the foreign key (using the ALTER TABLE statement) or the child table itself.

SQL Operators

In SQL, an operator is a symbol specifying an action that is performed on one or more expressions.

Operators manipulate individual data items and return a result. The data items are called operands or arguments . In SQL, operators are represented by special characters or by keywords.

We’ve already seen some operators in action. Some of our previous example queries had a WHERE clause that included the Equals operator (= ). We also ran a query that used the Greater Than operator (> ). These are both comparison operators – they compare two expressions.

See 12 Commonly Used Operators in SQL for examples of operators that you’re likely to need when working with SQL.

You can also use this list of SQL Operators as a reference for the operators available in SQL.

SQL Views

In SQL, a view is a query that’s saved to the database as a database object (just like a table). The term can also be used to refer to the result set of a stored query. Views are often referred to as virtual tables .

To create a view, you write a query, then save it as a view. You do this using the CREATE VIEW syntax.

Here’s an example of creating a view:

CREATE VIEW vPetTypeCount AS
SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType;

Running that code creates the view and stores it as an object in the database.

We can now query the view, just like we’d query a table.

Ergebnis:

SELECT * FROM vPetTypeCount;

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Bird      | 1       |
| Cat       | 3       |
| Dog       | 4       |
+-----------+---------+

So we get the same result as we would have got if we’d run the original query, but saving it in a view made it a lot easier to query.

This benefit would become greater, the more complex the query is.

Views and the ORDER BY Clause

One thing I should point out is that the original query had an ORDER BY clause, but I didn’t include that in the view. The SQL standard does not allow the ORDER BY clause in any view definition. Also, most RDBMSs will raise an error if you try to include an ORDER BY Klausel.

This isn’t a problem though, because you can sort the results when you query the view. Therefore, we can do something like this:

SELECT * FROM vPetTypeCount
ORDER BY Count DESC;

Ergebnis:

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Most RDBMSs also include a large set of system views that you can use to retrieve information about the system.

For more about views, see What is a View?

Stored Procedures

A stored procedure is a series of SQL statements compiled and saved to the database. Stored procedures are similar to views in some respects, but very different in other respects.

One of the benefits of stored procedures is that they allow you to store complex scripts on the server. Stored procedures often contain conditional programming such as IF... ELSE statements, for example. Stored procedures can also accept parameters.

Here’s an example of creating a simple stored procedure in SQL Server to get pet information from our database:

CREATE PROCEDURE uspGetPetById
    @PetId int
AS
    SET NOCOUNT ON;
    SELECT 
        p.PetName, 
        p.DOB, 
        pt.PetType,
        CONCAT(o.FirstName, ' ', o.LastName) AS OwnerName
    FROM Pets p 
    INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
    INNER JOIN Owners o 
    ON o.OwnerId = p.OwnerId
    WHERE p.PetId = @PetId;

This stored procedure accepts a parameter called @PetId . This means that when you call the procedure, you need to pass the ID of the pet that you’d like information about. The procedure then selects data from various tables and returns it.

To call the stored procedure, use the EXECUTE Erklärung. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL Aussage.

EXEC uspGetPetById @PetId = 3;

Ergebnis:

+-----------+------------+-----------+-------------+
| PetName   | DOB        | PetType   | OwnerName   |
|-----------+------------+-----------+-------------|
| Scratch   | 2018-10-01 | Cat       | Bart Pitt   |
+-----------+------------+-----------+-------------+

In this case I was interested in pet number 3, and so that’s the info that I got.

I should mention that the syntax for creating stored procedures can differ quite significantly between DBMSs (as well as their implementations of various SQL statements and commands that you’d use inside a procedure), so I would suggest that you look at the documentation for your particular DBMS if you want to create a stored procedure.

Most RDBMSs also include a large set of system stored procedures that you can use to perform various administration tasks, and to retrieve information about the system.

For a basic overview of stored procedures, including their benefits, see What is a Stored Procedure?

Also, if you’re interested, see How to Create a Stored Procedure in SQL Server to see another example of creating a stored procedure in SQL Server. That example includes some screenshots.

SQL Triggers

A trigger is a special type of stored procedure that automatically executes when an event occurs in the database server.

Most major RDBMSs support DML triggers, which execute when a user tries to modify data through a data manipulation language (DML) event. DML events are INSERT , UPDATE , or DELETE statements.

Some DBMSs (such as SQL Server and PostgreSQL) allow triggers to be associated with both tables and views. Others only allow triggers to be associated with tables.

SQL Server also supports DDL triggers and logon triggers.

DDL triggers execute in response to DDL events, such as CREATE , ALTER , and DROP statements, and certain system stored procedures that perform DDL-like operations.

Logon triggers are fired in response to the LOGON event that’s raised when a user’s session is being established.

Here are some articles explaining how to do various things with triggers in SQL Server:

• Create a DML Trigger in SQL Server
• Create a “last modified” column
• Automatically send an email when someone tries to delete a record
• Update a column’s value whenever another column is updated
• Update a column’s value whenever certain other columns are updated

SQL Transactions

SQL transactions are an important part of transactional databases, where data consistency is paramount.

A transaction manages a sequence of SQL statements that must be executed as a single unit of work. This is to ensure that the database never contains the results of partial operations.

When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

Transactions help maintain data integrity by ensuring that a sequence of SQL statements execute completely or not at all.

A classic example of a transaction is to move money from one bank account to another. You wouldn’t want money to be deducted from the first bank account, but not appear in the second bank account.

Therefore, you could use a transaction which goes along the lines of this:

START TRANSACTION
Debit account 1
Credit account 2
Record transaction in transaction journal
END TRANSACTION 

You could write conditional logic inside that transaction that rolls back the transaction if anything goes wrong.

The end result is that, either the transaction is completed in its entirety, or it’s not completed at all. It’s never half-done.

See my SQL Transactions Tutorial for examples of SQL transactions.

SQL Functions

A function is a routine that can take parameters, perform calculations or other actions, and return a result.

Most DBMSs provide you with the ability to create your own functions, while also providing a range of inbuilt functions.

User-Defined Functions

A user-defined function (UDF) is a function that you create for a specific purpose, and save to the database. You would create such a function for tasks that aren’t catered for by an inbuilt function.

See Introduction to User-Defined Functions in SQL Server for an overview. Although that article is written for SQL Server, most of the general concepts also apply to other DBMSs.

Inbuilt Functions

Most DBMSs have a large range of inbuilt functions that you can use in your SQL queries. For example, there are functions that return the current date and time, functions that format dates and numbers, functions that convert data from one data type to another, and more.

The range of inbuilt functions can be pretty extensive, and depend on the DBMS in use, so I won’t go over them in this SQL tutorial. But I would encourage you to try to find out what inbuilt functions your DBMS supports.

To get you started, the following articles contain some of the most commonly used functions in SQL programming.

SQL Server

• SQL Server String Functions
• SQL Server Mathematical Functions
• SQL Server Date &Time Functions

MySQL

• MySQL String Functions
• MySQL Mathematical Functions

PostgreSQL

• PostgreSQL Date &Time Functions
• PostgreSQL Math Functions

SQLite

• SQLite Aggregate Functions
• SQLite Date &Time Functions