SQL-zelfstudie voor beginners

In deze SQL-zelfstudie voor beginners maakt u uw eigen database, voegt u gegevens in die database in en voert u vervolgens query's uit op die database.

Met deze SQL-tutorial kunt u in een mum van tijd SQL-query's uitvoeren!

SQL-voorbeeld

Hier is een voorbeeld van een SQL-instructie:

SELECT * 
FROM Pets;

Dit is een perfect voorbeeld van hoe gemakkelijk het kan zijn om SQL te schrijven. Deze eenvoudige SQL-instructie doet eigenlijk veel. Het geeft de hele tabel terug. Het retourneert alle kolommen en alle rijen uit de tabel met de naam Pets .

Het sterretje (* ) is een jokerteken, wat 'alle kolommen' betekent. Het is een snelle en gemakkelijke manier om alle kolommen te krijgen zonder ze allemaal uit te typen.

Dat is een van de mooie dingen van SQL. De eenvoudigste SQL-query's zijn meestal de krachtigste. Als we minder gegevens wilden retourneren, zouden we eigenlijk meer . moeten schrijven .

Als we bijvoorbeeld alleen huisdieren wilden met de naam Fetch , zouden we een WHERE . toevoegen clausule die dat vereiste bepaalde.

Zoals dit:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

De WHERE clausule filtert onze zoekopdracht naar alleen de rijen waar de PetName kolom heeft een waarde van Fetch .

Deze zoekopdracht gaat ervan uit dat er een kolom is met de naam PetName en een tabel genaamd Pets in de databank.

In deze SQL-tutorial laat ik je zien hoe je zo'n database kunt maken met SQL.

Ik laat je ook zien hoe je gegevens in die database kunt invoegen, gegevens kunt bijwerken, gegevens kunt verwijderen en er query's op kunt uitvoeren.

Wat is SQL?

SQL is een acroniem voor Structured Query Language.

SQL is de standaard zoektaal die wordt gebruikt voor het werken met relationele databases.

SQL wordt gebruikt door alle grote relationele databasebeheersystemen (RDBMS'en), waaronder:

Microsoft-toegang
SQL-server
Oracle
PostgreSQL
MijnSQL
SQLite

Wat kan ik doen met SQL?

U kunt SQL gebruiken om query's op een database uit te voeren, records in te voegen, records bij te werken en records te verwijderen. U kunt ook nieuwe database-objecten maken, zoals databases en tabellen. U kunt ook databasebeheertaken uitvoeren, zoals het maken van aanmeldingen, geautomatiseerde taken, databaseback-ups en nog veel meer.

Zelfs als u dingen doet met een grafische gebruikersinterface (GUI), zal uw databasebeheersysteem (DBMS) vrijwel zeker achter de schermen SQL gebruiken om die taak uit te voeren.

Als u bijvoorbeeld een database maakt door op Database maken te klikken, en het invoeren van de details van de nieuwe database in een dialoogvenster, zodra u op OK . klikt of Maken of wat de knop ook leest, uw databasesysteem gebruikt de SQL CREATE DATABASE statement om door te gaan en de database aan te maken zoals gespecificeerd.

Hetzelfde geldt voor andere taken, zoals het uitvoeren van query's, het invoegen van gegevens, enz.

Met SQL kunt u ook meer geavanceerde acties uitvoeren, zoals het maken van opgeslagen procedures (op zichzelf staande scripts), weergaven (vooraf gemaakte query's) en het instellen van machtigingen voor database-objecten (zoals tabellen, opgeslagen procedures en weergaven).

Dat gezegd hebbende, je hoeft niet alle geavanceerde dingen te leren om met SQL aan de slag te gaan. Het goede aan SQL is dat sommige van de meest voorkomende taken het gemakkelijkst te schrijven zijn.

SQL-standaard

SQL werd in 1986 gestandaardiseerd in ANSI X3.135 en binnen een paar maanden werd het door ISO overgenomen als ISO 9075-1987. De internationale norm (nu ISO/IEC 9075) is sindsdien regelmatig herzien en bestaat momenteel in 9 delen.

De meeste grote databaseleveranciers hebben de neiging zich te houden aan de SQL-standaard. Het goede hieraan is dat u niet elke keer dat u een nieuw DBMS leert een nieuwe querytaal hoeft te leren.

In de praktijk zijn er echter verschillen tussen de manier waarop elke databaseleverancier de SQL-standaard implementeert. Daarom werkt code die u in het ene DBMS schrijft mogelijk niet altijd in een ander DBMS zonder dat er wijzigingen nodig zijn.

Het goede nieuws is dat alle grote DBMS'en de meest voorkomende taken op dezelfde manier ondersteunen.

SQL-uitspraak

SQL wordt meestal op twee manieren uitgesproken:

“ess-que-el ” (d.w.z. elke letter spellen)
“vervolg ” (zoals in de originele spelling/uitspraak).

Zie Is het uitgesproken als S-Q-L of vervolg als je je afvraagt waarom.

Wat heb ik nodig voor deze SQL-zelfstudie?

Om echt te profiteren van deze SQL-tutorial, moet u de voorbeelden volgen. Dat betekent dat je ergens nodig hebt om de SQL-query's in te voeren. Je hebt zoiets als dit nodig:

Als u SQL-query's gaat uitvoeren, heeft u het volgende nodig:

Een RDBMS geïnstalleerd (zoals SQL Server, MySQL, PostgreSQL, SQLite, enz.).
Een databasehulpprogramma waarmee u SQL-query's kunt uitvoeren op dat RDBMS (zoals MySQL WorkBench, Azure Data Studio (afgebeeld), DBeaver en SSMS).

Als je al een van elk hebt geïnstalleerd, geweldig! U kunt doorgaan met de tutorial.

Als u deze niet hebt geïnstalleerd, raadpleegt u Wat heb ik nodig om SQL uit te voeren? voor instructies over het installeren van een RDBMS en het relevante hulpprogramma voor databasebeheer, voordat u terugkeert naar deze SQL-zelfstudie.

Een database maken

Nadat u uw RDBMS en de juiste databasetool hebt geïnstalleerd, bent u klaar om een database te maken:

CREATE DATABASE PetHotel;

Klaar!

Die verklaring creëerde eigenlijk een database. Een lege database, maar toch een database.

Deze database bevat de tabellen en gegevens die in deze SQL-zelfstudie worden gebruikt. Wanneer we een tabel maken of gegevens invoegen, doen we dit in deze database.

Ik moet vermelden dat SQLite een andere syntaxis gebruikt voor het maken van databases. Als u SQLite gebruikt, kunt u als volgt een database maken in SQLite.

Verbinding maken met de database

Voordat u begint met het maken van tabellen, het invoegen van gegevens, enzovoort, moet u zeker weten dat u zich in de juiste database bevindt. Het maken van een database (zoals we net deden) verbindt u niet noodzakelijk met die database.

In veel DBMS'en (zoals SQL Server , MySQL en MariaDB ), kunnen we het volgende gebruiken om over te schakelen naar de opgegeven database:

USE PetHotel;

Dat maakt PetHotel de huidige database.

In SQLite , bevindt u zich waarschijnlijk al in de database nadat u deze hebt gemaakt. Zo niet, dan kunt u de database bijvoegen (die deze ook aanmaakt als deze nog niet bestaat):

ATTACH DATABASE 'PetHotel.db' AS Pets;

In PostgreSQL , als u de psql-tool gebruikt, kunt u het volgende gebruiken:

\connect PetHotel

Of de verkorte versie:

\c PetHotel

Ik moet vermelden dat het proces van het maken van en het verbinden met databases sterk kan verschillen tussen DBMS'en.

Gelukkig kun je met de meeste GUI-tools verbinding maken met een database door te dubbelklikken op de database of door met de rechtermuisknop op de databasenaam te klikken en een nieuw querytabblad te selecteren in het contextmenu. Als je merkt dat je vastzit bij deze stap, gebruik dan gewoon de GUI om je database aan te maken en/of er verbinding mee te maken.

Maak een tabel

Nu je verbinding hebt gemaakt met de juiste database, kun je doorgaan en enkele tabellen maken.

Om een tabel in SQL aan te maken, gebruik je de CREATE TABLE verklaring.

Wanneer u een tabel maakt, moet u specificeren welke kolommen in de tabel zullen staan, evenals hun gegevenstypes. Je kunt ook andere details opgeven, maar laten we niet op de zaken vooruitlopen.

Laten we een tabel maken:

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

In dit geval maken we een tabel met de naam PetTypes . Dat weten we, want de tabelnaam komt direct na de CREATE TABLE beetje.

Daarna komt een lijst met kolommen tussen haakjes.

De bovenstaande tabel bevat de volgende kolommen:

PetIdId
PetType

Elke kolom wordt gevolgd door het gegevenstype:

int betekent dat deze kolom gehele getallen accepteert. Voor zover ik weet, ondersteunen de meeste grote DBMS'en het declareren van kolommen als int . Als je problemen hebt, probeer dan integer .
varchar(60) betekent dat deze kolom strings van maximaal 60 tekens accepteert. varchar kolommen zijn tekenreeksen met variabele lengte. Een ander gegevenstype string is char (wat een string met een vaste lengte is). Als je problemen hebt met het definiëren van een kolom als varchar(60) , probeer char(60) . te gebruiken .

`NOT NULL` Beperkingen

In dit voorbeeld zijn beide kolommen gedefinieerd met NOT NULL beperkingen. De NOT NULL beperking betekent dat deze kolom niet leeg mag zijn. Wanneer een nieuwe rij wordt ingevoegd, wordt elke NOT NULL kolommen moeten een waarde bevatten. Andere kolommen kunnen leeg blijven als er geen gegevens voor die kolommen zijn.

Als NULL waarden zijn toegestaan in de kolom, u kunt de NOT NULL . weglaten deel, of declareer het als NULL (wat betekent, NULL waarden zijn toegestaan in deze kolom).

Sommige DBMS'en (zoals DB2) ondersteunen de NULL . niet zoekwoord sowieso, en u zult het dus moeten weglaten als u met dergelijke DBMS'en werkt.

Primaire toetsen

We hebben ook de PetTypeId . gemaakt kolom de primaire sleutel. De primaire sleutel is een of meer kolommen die elke rij in de tabel op unieke wijze identificeert. U specificeert uw geselecteerde kolom(men) als de primaire sleutel door een primaire sleutelbeperking te gebruiken. U kunt dit doen in de CREATE TABLE statement (zoals we hier deden), of je kunt er later een toevoegen met een ALTER TABLE uitspraak.

Primaire sleutels moeten unieke waarden bevatten. Dat wil zeggen, voor elke rij in die tabel moet de waarde in de primaire sleutelkolom(men) in elke rij anders zijn. Dit kan zo simpel zijn als het hebben van oplopende nummers (zoals 1, 2, 3... etc) of het kan een productcode zijn (zoals pr4650, pr2784, pr5981... etc).

Ook moeten primaire sleutels een waarde bevatten. Het kan niet NULL zijn .

Hoewel primaire sleutels niet vereist zijn, wordt het over het algemeen als een goede gewoonte beschouwd om voor elke tabel een primaire sleutel te definiëren.

Maak meer tabellen

Laten we nog twee tabellen maken:

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
);

Beide tabellen zijn vergelijkbaar met de eerste, behalve dat ze meer rijen hebben en een paar extra stukken, die ik hieronder zal uitleggen.

Als je geïnteresseerd bent, bekijk dan SQL CREATE TABLE for Beginners voor nog een paar eenvoudige voorbeelden van het maken van tabellen in SQL.

Relaties

Toen we onze Pets created maakten tabel hebben we eigenlijk een relatie tussen de drie tabellen gemaakt.

Die relatie wordt weergegeven in het volgende diagram.

Databaserelaties zijn een cruciaal onderdeel van SQL. Dankzij relaties kunnen we meerdere tabellen doorzoeken op gerelateerde gegevens en nauwkeurige en consistente resultaten krijgen.

In ons geval willen we huisdieren kunnen zoeken op eigenaar, of huisdieren op huisdiertype, enz. En we willen dat onze resultaten nauwkeurig en consistent zijn.

Om dit te bereiken, moeten we erop aandringen dat alle huisdieren worden ingeschreven samen met hun eigenaar en huisdiertype. Daarom moeten we ervoor zorgen dat, wanneer een nieuw huisdier wordt toegevoegd aan de Pets tabel, is er al een corresponderende eigenaar in de Owners tabel en een bijbehorend huisdiertype in de PetTypes tafel.

In principe zijn onze vereisten als volgt:

Elke waarde in de Pets.PetTypeId kolom moet overeenkomen met een waarde in de PetTypes.PetTypeId kolom.
Elke waarde in de Pets.OwnerId kolom moet overeenkomen met een waarde in de Owners.OwnerId kolom.

We kunnen aan de bovenstaande vereisten voldoen door een externe sleutelbeperking te creëren voor de toepasselijke kolommen. Een buitenlandse sleutel beperking wordt gebruikt om aan te geven dat een bepaalde kolom verwijst naar de primaire sleutel van een andere tabel.

De bovenstaande code heeft inderdaad twee externe sleutelbeperkingen gecreëerd voor de Pets tafel.

Merk op dat de PetTypeId en OwnerId kolommen hebben een extra code die begint met REFERENCES... . Dat zijn de onderdelen die de twee externe sleutels hebben gemaakt.

Toen we de Pets . maakten tabel, zijn PetTypeId kolom heeft een bit dat gaat REFERENCES PetTypes (PetTypeId) . Dit betekent dat de Pets.PetTypeId kolom verwijst naar de PetTypeId kolom in de PetTypes tafel.

Het is dezelfde deal voor de OwnerId kolom. Het verwijst naar de OwnerId kolom van de Owners tafel.

In de meeste DBMS'en kunnen externe sleutels ook worden gemaakt op een bestaande tabel, met behulp van de ALTER TABLE verklaring, maar daar gaan we hier niet op in. Zie Een relatie maken in SQL voor meer informatie hierover.

Hoe dan ook, onze externe sleutels zijn gemaakt. Nu, wanneer iemand een nieuw huisdier invoegt in de Pets tabel, de PetTypeId en OwnerId waarden moeten een overeenkomstige waarde hebben in de PetTypes en Owners tabellen respectievelijk. Als een van hen dat niet doet, retourneert de database een fout.

Dit is het voordeel van buitenlandse sleutels. Het helpt voorkomen dat er verkeerde gegevens worden ingevoerd. Het helpt de gegevensintegriteit en meer specifiek de referentiële integriteit te behouden.

Beperkingen controleren

Een controlebeperking is een ander type beperking waarvan u zich bewust moet zijn. Een controlebeperking controleert gegevens voordat deze de database binnenkomen. Wanneer voor een tabel een controlebeperking is ingeschakeld, kunnen gegevens alleen in de tabel worden ingevoerd als deze die beperking niet schendt. Gegevens die de beperking schenden, kunnen niet in de tabel komen.

U kunt bijvoorbeeld een controlebeperking maken voor een Price kolom om ervoor te zorgen dat deze alleen waarden accepteert die groter zijn dan nul. Of we kunnen een controlebeperking toepassen op onze Pets tabel om ervoor te zorgen dat de DOB kolom is niet in de toekomst.

Zie voor een voorbeeld Wat is een CHECK-beperking?

Witruimte

Het is je misschien opgevallen dat mijn voorbeelden witruimte bevatten. Ik heb de code bijvoorbeeld over meerdere regels verdeeld en ik heb tabs gebruikt om de gegevenstypen te laten inspringen, enz.

Dit is perfect geldig in SQL. U kunt dit veilig doen en het heeft geen invloed op het resultaat. Met SQL kunt u uw code desgewenst over meerdere regels verspreiden en kunt u meerdere spaties of tabbladen gebruiken om de leesbaarheid te verbeteren.

Opmerkingen

U kunt ook opmerkingen in uw code opnemen. Opmerkingen kunnen handig zijn als u eenmaal langere SQL-scripts gaat schrijven. Zodra een script behoorlijk lang wordt, kunnen opmerkingen het gemakkelijker maken om snel te identificeren wat elk onderdeel doet.

Inline opmerkingen

U kunt inline opmerkingen maken door uw opmerking vooraf te laten gaan door twee koppeltekens (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

In dit voorbeeld worden beide query's zonder problemen uitgevoerd. De opmerkingen worden door het DBMS genegeerd.

Opmerkingen met meerdere regels

U kunt opmerkingen over meerdere regels verspreiden door de opmerking te omringen met /* en */ :

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

In dit voorbeeld worden beide query's zonder problemen uitgevoerd. De opmerkingen worden door het DBMS genegeerd.

MySQL

Als u MySQL gebruikt, kunt u ook het hekje/hekje gebruiken (# ) voor opmerkingen van één regel.

# This is a comment
SELECT * FROM Pets;

Code voor commentaar geven

Een ander leuk voordeel van reacties is dat je opmerkingen kunt geven code. Als u bijvoorbeeld een lang SQL-script heeft dat veel dingen doet, maar u slechts een of twee delen ervan wilt uitvoeren, kunt u opmerkingen geven de rest van het script.

Hier is een voorbeeld:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

In dit geval is de eerste SELECT statement is uitgecommentarieerd, en dus alleen de tweede SELECT instructie wordt uitgevoerd.

U kunt voor deze techniek ook opmerkingen met meerdere regels gebruiken.

Gegevens invoegen

Nu we drie tabellen hebben gemaakt en de juiste externe sleutels hebben gemaakt, kunnen we doorgaan en gegevens toevoegen.

De meest gebruikelijke manier om gegevens in SQL in te voegen is met de INSERT uitspraak. Het gaat ongeveer als volgt:

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

U vervangt eenvoudig MyTable met de naam van de tabel waarin u gegevens invoegt. Op dezelfde manier vervangt u Column1 , etc met de kolomnamen, en Value1 , enz. met de waarden die in die kolommen komen te staan.

We zouden dit bijvoorbeeld kunnen doen:

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

Elke waarde staat in dezelfde volgorde als waarin de kolom is opgegeven.

Merk op dat de kolomnamen overeenkomen met de namen die we gebruikten toen we de tabel maakten.

U kunt de kolomnamen weglaten als u gegevens in alle kolommen invoegt. We kunnen het bovenstaande voorbeeld er dus als volgt uit laten zien:

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

Voor deze tutorial zullen we nog een flink aantal rijen toevoegen, dus we zullen meer INSERT INTO toevoegen statements – één voor elke rij die we willen invoegen.

Dus laten we doorgaan en onze tafels vullen.

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' );

Merk op dat we de Pets . hebben ingevuld tafel als laatste. Daar is een reden voor.

Als we hadden geprobeerd gegevens in te voegen in de Pets tabel voordat we de andere twee vulden, zouden we een fout hebben ontvangen vanwege onze externe sleutelbeperking. En met een goede reden. We zouden tenslotte hebben geprobeerd waarden in te voegen in de refererende-sleutelkolommen die nog niet bestonden in de primaire-sleutelkolommen in de andere tabellen. Dat is een groot "nee nee" als het gaat om buitenlandse sleutels.

Dus door de Owners . in te vullen en PetTypes tabellen, zorgden we ervoor dat de juiste waarden al in de primaire sleutelkolommen stonden voordat we de externe sleutelkolommen in de Pets vulden tafel.

Zie SQL INSERT voor beginners voor meer voorbeelden van het invoegen van gegevens in tabellen.

Controleer onze gegevens

Opluchting! Eindelijk kunnen we beginnen met het uitvoeren van query's op onze database.

Laten we de gegevens in al onze tabellen controleren.

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

Resultaat:

+---------+-------------+-----------+-----------+------------+
| 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)

Geweldig, dus het lijkt erop dat de gegevens met succes zijn ingevoegd.

Selecteer specifieke kolommen

Het wordt over het algemeen als een slechte gewoonte beschouwd om alle rijen en alle kolommen uit een tabel te selecteren (zoals we deden in het vorige voorbeeld), tenzij het echt nodig is. Dit kan van invloed zijn op de prestaties van uw databaseserver, vooral als er veel rijen in de tabel staan.

Het is geen probleem wanneer u kleine datasets gebruikt zoals wij hier zijn, of als u zich in een ontwikkelomgeving of iets dergelijks bevindt. Anders is het meestal beter om alleen de kolommen te selecteren die u nodig heeft.

Daarom, als we de ID's, namen en geboortedata van alle huisdieren wilden, zouden we dit kunnen doen:

SELECT PetId, PetName, DOB 
FROM Pets;

Resultaat:

+---------+-----------+------------+
| 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       |
+---------+-----------+------------+

Als we de ID's en de geboortedatum van alle huisdieren met de naam Fluffy wilden, zouden we dit kunnen gebruiken:

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

Resultaat:

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

U kunt ook de SELECT . gebruiken statement om gegevens zonder tabel te retourneren. Dat wil zeggen, het kan gegevens retourneren die niet in een tabel zijn opgeslagen. Zie SQL SELECT Verklaring voor beginners om een voorbeeld te zien.

Sorteren

SQL biedt de ORDER BY clausule die ons in staat stelt om gegevens te sorteren.

We kunnen een ORDER BY . toevoegen clausule naar ons eerdere voorbeeld zodat de huisdieren op hun naam worden gesorteerd:

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

Resultaat:

+---------+-----------+------------+
| 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 |
+---------+-----------+------------+

De ASC deel betekent oplopend . Wanneer u de ORDER BY . gebruikt clausule, is deze standaard oplopend, dus u kunt de ASC . weglaten deel als je wilt.

Om het te sorteren in aflopend bestel, gebruik DESC .

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

Resultaat:

+---------+-----------+------------+
| 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       |
+---------+-----------+------------+

U kunt de resultaten ook sorteren met meerdere kolommen. Het sorteert op de eerste gespecificeerde kolom, en als er duplicaten in die kolom zijn, zal het die duplicaten sorteren op de tweede gespecificeerde kolom, enzovoort.

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

Resultaat:

+---------+-----------+------------+
| 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       |
+---------+-----------+------------+

Kijk hoe de twee Fluffy's van positie zijn verwisseld.

Als u de ORDER BY . niet gebruikt clausule, is er geen garantie in welke volgorde uw resultaten zullen staan. Hoewel het er misschien lijkt alsof uw database de resultaten sorteert op een bepaalde kolom, is dit mogelijk niet het geval. Over het algemeen zonder ORDER BY clausule, worden gegevens gesorteerd in de volgorde waarin ze in de tabel zijn geladen. Als rijen echter zijn verwijderd of bijgewerkt, wordt de volgorde beïnvloed door de manier waarop het DBMS de teruggewonnen opslagruimte opnieuw gebruikt.

Vertrouw daarom niet op het DBMS om de resultaten in een zinvolle volgorde te sorteren.

Kort gezegd:als u wilt dat uw resultaten worden gesorteerd, gebruikt u ORDER BY .

Zie SQL ORDER BY Clausule voor beginners voor meer voorbeelden.

Tel de rijen in een resultatenset

U kunt de COUNT() . gebruiken aggregatiefunctie om de rijen te tellen die in een query worden geretourneerd.

SELECT COUNT(*) AS Count
FROM Pets;

Resultaat:

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

Dit vertelt ons dat er 8 rijen in de tabel zijn. Dat weten we omdat we alle rijen en alle kolommen hebben geselecteerd.

U kunt COUNT() . gebruiken op elke zoekopdracht, bijvoorbeeld zoekopdrachten die een WHERE . gebruiken clausule om de resultaten te filteren.

U kunt ook een bepaalde kolom opgeven om te tellen. De COUNT() functie telt alleen niet-NULL resultaten, dus als u een kolom specificeert die NULL . bevat waarden, worden die waarden niet meegeteld.

Hier is een voorbeeld om te laten zien wat ik bedoel.

SELECT COUNT(DOB) AS Count
FROM Pets;

Resultaat:

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

U herinnert zich misschien dat de Pets tabel bevat twee NULL waarden in de DOB kolom (twee huisdieren hebben hun geboortedatum niet opgegeven), en dus COUNT(DOB) geeft 6 terug, in plaats van 8 toen we COUNT(*) gebruikten . De reden COUNT(*) alle rijen heeft geretourneerd, is omdat die twee rijen deed gegevens in de andere kolommen hebben.

In mijn voorbeeld heeft mijn DBMS hier ook een waarschuwing over geretourneerd. U kunt wel of geen waarschuwing krijgen, afhankelijk van uw DBMS en uw specifieke configuratie.

Zie SQL COUNT voor beginners voor meer voorbeelden.

Andere verzamelfuncties zijn onder meer:AVG() , SUM() , MIN() , en MAX() .

Groeperen op

Een andere handige clausule is de GROUP BY clausule. Dit doet vrijwel wat de naam belooft. Hiermee kunt u de resultaten groeperen op een bepaalde kolom.

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

Resultaat:

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

In dit voorbeeld tellen we hoeveel huisdieren we hebben voor elk huisdiertype en sorteren we het vervolgens in aflopende volgorde (met het hoogste aantal bovenaan).

Zie SQL GROUP BY Clausule voor beginners voor meer voorbeelden.

Het `HAVING` Clausule

We kunnen de HAVING . gebruiken clausule om de resultaten te filteren in de GROUP BY clausule. De HAVING clausule retourneert rijen waar geaggregeerde waarden voldoen aan gespecificeerde voorwaarden.

Hier is een voorbeeld.

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

Resultaat:

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

In dit geval hebben we gegevens geretourneerd voor alleen de huisdiertypen waaraan meer dan 2 huisdieren zijn toegewezen.

Zie SQL HAVING Clausule voor beginners voor meer voorbeelden.

Doe mee

In SQL, een join is waar u een query uitvoert die gegevens uit meerdere tabellen combineert.

De vorige twee voorbeelden zijn oké, maar het zou beter zijn als ze de werkelijke huisdiertypes (bijv. Kat, Hond, Vogel, enz.) zouden retourneren in plaats van de ID (bijv. 1, 2, 3, enz.).

Het enige probleem is, de Pets tabel bevat die gegevens niet. Die gegevens staan in de PetTypes tafel.

Gelukkig voor ons kunnen we een join doen tussen deze twee tabellen. Hier is een voorbeeld dat gebruikmaakt van een LEFT JOIN :

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;

Resultaat:

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

Deze resultatenset is veel gemakkelijker te lezen dan de vorige. Het is gemakkelijker om te zien hoeveel van elk huisdiertype er in de tabel staan.

De syntaxis gebruikt het join-type (in dit geval LEFT JOIN ), gevolgd door de eerste (linker) tabel, gevolgd door ON , gevolgd door de deelnamevoorwaarde.

Laten we een INNER JOIN gebruiken om alle namen van huisdieren te retourneren met hun respectievelijke huisdiertypes.

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

Resultaat:

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

Joins openen echt onze opties, omdat we nu gegevens uit meerdere tabellen kunnen halen en deze kunnen presenteren alsof het een enkele tabel is.

U zult merken dat we in de join-voorbeelden onze kolomnamen kwalificeren met de tabelnamen. De reden dat we dit doen is om onduidelijkheid over de kolomkolomnamen tussen de tabellen te voorkomen. Beide tabellen kunnen kolommen met dezelfde naam hebben (zoals in ons voorbeeld), en in dergelijke gevallen weet het DBMS niet naar welke kolom u verwijst. Door de kolomnamen vooraf te laten gaan door hun tabelnamen zorgt u ervoor dat u naar de juiste kolom verwijst en voorkomt u fouten die zouden kunnen voortvloeien uit onduidelijkheid over de kolom waarnaar u verwijst.

Zie mijn SQL Joins Tutorial voor meer voorbeelden en een uitleg van de verschillende join-types.

Aliasen

We kunnen een stap verder gaan en een alias . toewijzen aan elke tabelnaam en kolomnaam.

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

Resultaat:

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

Dit heeft geresulteerd in nieuwe kolomkoppen en de code is beknopter.

Met een alias kunt u tijdelijk een andere naam aan een tabel of kolom toewijzen voor de duur van een SELECT vraag. Dit kan met name handig zijn wanneer tabellen en/of kolommen zeer lange of complexe namen hebben.

Een alias wordt toegewezen door het gebruik van de AS trefwoord, hoewel dit trefwoord optioneel is, kunt u het dus gerust weglaten. Merk op dat Oracle de AS . niet ondersteunt trefwoord op tabelaliassen (maar wel op kolomaliassen).

In het bovenstaande voorbeeld heb ik de AS trefwoord bij het toewijzen van de kolomaliassen, maar weggelaten bij het toewijzen van de tabelaliassen.

Een aliasnaam kan van alles zijn, maar wordt voor de leesbaarheid meestal kort gehouden.

In ons geval hebben we de twee tabellen gewijzigd in p en pt , en de kolomnamen naar Pet en Pet Type . Merk op dat ik Pet Type heb omringd tussen dubbele aanhalingstekens. Ik deed dit, omdat er een spatie in de naam zit. Voor aliassen zonder spaties hoeft u dit niet te doen. In SQL Server kunt u ook vierkante haken gebruiken ([] ) in plaats van dubbele aanhalingstekens (hoewel het ook dubbele aanhalingstekens ondersteunt).

Het gebruik van spaties in kolommen en aliassen wordt over het algemeen afgeraden, omdat dit bij sommige clienttoepassingen allerlei problemen kan veroorzaken.

Merk op dat we nog steeds de volledige kolomnamen moesten gebruiken bij het verwijzen naar hen in de join (na de ON zoekwoord).

Ik moet erop wijzen dat het toewijzen van een alias de kolom of tabel niet daadwerkelijk hernoemt.

Zie SQL Alias Explained voor meer voorbeelden.

Gegevens bijwerken

U kunt de UPDATE . gebruiken statement om gegevens in uw tabellen bij te werken.

De basissyntaxis is vrij eenvoudig:

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

In dat voorbeeld werken we de LastName . bij kolom om een nieuwe waarde van Stallone te hebben waar de OwnerId is 3 .

Om meerdere kolommen bij te werken, gebruikt u een komma om elk kolom/waarde-paar te scheiden.

Maar wat je ook doet, vergeet de WHERE . niet clausule (tenzij u van plan bent om elke rij in de tabel bij te werken met dezelfde waarde).

Zie SQL UPDATE voor beginners voor meer voorbeelden en een meer gedetailleerde uitleg.

Gegevens verwijderen

U kunt de DELETE . gebruiken statement om gegevens uit uw tabellen te verwijderen.

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

DELETE FROM Owners
WHERE OwnerId = 5;

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

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 syntaxis.

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.

Resultaat:

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 clausule.

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;

Resultaat:

+-----------+---------+
| 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 uitspraak. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL verklaring.

EXEC uspGetPetById @PetId = 3;

Resultaat:

+-----------+------------+-----------+-------------+
| 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 verklaringen.

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

SQL-zelfstudie voor beginners

SQL-voorbeeld

Wat is SQL?

Wat kan ik doen met SQL?

SQL-standaard

SQL-uitspraak

Wat heb ik nodig voor deze SQL-zelfstudie?

Een database maken

Verbinding maken met de database

Maak een tabel

NOT NULL Beperkingen

Primaire toetsen

Maak meer tabellen

Relaties

Beperkingen controleren

Witruimte

Opmerkingen

Inline opmerkingen

Opmerkingen met meerdere regels

MySQL

Code voor commentaar geven

Gegevens invoegen

Controleer onze gegevens

Selecteer specifieke kolommen

Sorteren

Tel de rijen in een resultatenset

Groeperen op

Het HAVING Clausule

Doe mee

Aliasen

Gegevens bijwerken

Gegevens verwijderen

Dropping Objects

SQL Operators

SQL Views

Views and the ORDER BY Clause

Stored Procedures

SQL Triggers

SQL Transactions

SQL Functions

User-Defined Functions

Inbuilt Functions

SQL Server

MySQL

PostgreSQL

SQLite

`NOT NULL` Beperkingen

Het `HAVING` Clausule