sql >> Database teknologi >  >> RDS >> Database

Grundlæggende SQL-forespørgsler

Denne artikel indeholder eksempler på grundlæggende SQL-forespørgsler, som begyndere kan bruge til at hente data fra deres databaser.

Grundlæggende SELECT Forespørgsel

Her er et eksempel på den muligvis mest brugte forespørgsel i SQL:

SELECT * 
FROM Pets;

Resultat:

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

Denne forespørgsel vælger alle rækker og alle kolonner fra Pets bord. Dette skyldes, at stjernen (* ) jokertegn vælger alle kolonner.

Vælg kolonnenavne

Af præstationsmæssige årsager er det normalt bedst at undgå at vælge alle kolonner, medmindre du virkelig har brug for dem. Det er normalt bedre at vælge netop de kolonner, du har brug for.

Her er et eksempel.

SELECT PetId, PetName
FROM Pets;

Resultat:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 2       | Fetch     |
| 3       | Scratch   |
| 4       | Wag       |
| 5       | Tweet     |
| 6       | Fluffy    |
| 7       | Bark      |
| 8       | Meow      |
+---------+-----------+

Filtrer resultaterne

Du kan tilføje en WHERE klausul for at filtrere resultaterne til kun de rækker, du har brug for.

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

Resultat:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 6       | Fluffy    |
+---------+-----------+

Her er et andet eksempel på filtrering af resultaterne. Denne gang bruger vi større end-operatoren (> ) for at filtrere den efter dato.

SELECT PetName, DOB 
FROM Pets
WHERE DOB > '2020-01-01';

Resultat:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

Du kan bytte større end-operatoren til andre operatorer, såsom større end eller lig med operatoren (>= ), mindre end operator (< ), eller mindre end eller lig med operatoren (<= ).

Du kan også bruge BETWEEN operatør for at filtrere resultaterne til et specifikt interval (f.eks. mellem to datoer).

SELECT
    PetName,
    DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';

Resultat:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
+-----------+------------+

Sortér resultaterne

Du kan tilføje en ORDER BY klausul for at sortere de rækker, der returneres af forespørgslen.

Stigende rækkefølge

Brug ASC nøgleord for at sortere resultaterne i stigende rækkefølge. Dette er standardværdien, så du kan også udelade dette søgeord, hvis du vil have resultaterne i stigende rækkefølge.

SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;

Eller:

SELECT PetId, PetName
FROM Pets
ORDER BY PetName;

Resultat:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+

Faldende rækkefølge

Brug DESC nøgleord for at sortere resultaterne i faldende rækkefølge.

SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;

Resultat:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 4       | Wag       |
| 5       | Tweet     |
| 3       | Scratch   |
| 8       | Meow      |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 2       | Fetch     |
| 7       | Bark      |
+---------+-----------+

Sortér efter flere kolonner

Du kan sortere efter flere kolonner ved at angive hver kolonne, adskilt af et komma.

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

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

Resultat:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+
(8 rows affected)
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 6       | Fluffy    |
| 1       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+
(8 rows affected)

Vi kan se, at de to Fluffys har en forskellig rækkefølge i hvert resultat (vi kan se ved at se på deres PetId værdier). Dette skyldes, at PetName kolonnen blev sorteret først, derefter PetId sorterede eventuelle dubletter fra den første sortering.

Sortér efter skjulte kolonner

Du kan sortere efter kolonner, der ikke er inkluderet i SELECT liste.

SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;

Resultat:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 5       | Tweet     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 4       | Wag       |
| 2       | Fetch     |
| 3       | Scratch   |
| 7       | Bark      |
| 8       | Meow      |
+---------+-----------+

I dette tilfælde kan vi udlede af disse resultater, at Tweet er det yngste kæledyr og Meow er den ældste. Dette skyldes, at vi sorterede efter deres fødselsdato (DOB ) kolonne i faldende rækkefølge.

Bare for at være sikker, her er den igen med DOB kolonne inkluderet i SELECT liste.

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

Resultat:

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

Faktisk kan vi nu se, at Meow og Bark har NULL værdier i DOB kolonne. Derfor ved vi ikke, om de faktisk er ældre eller yngre.

Men dette viser, at NULL værdier behandles som de lavest mulige værdier. Vær opmærksom på NULL værdier, når du kører forespørgsler.

Mønstertilpasning

Du kan bruge LIKE operatør for at bruge mønstertilpasning.

SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';

Resultat:

+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 2       | Fetch     |
| 6       | Fluffy    |
+---------+-----------+

I dette eksempel søger vi efter alle kæledyr, hvis navne starter med bogstavet F . Procenttegnet (% ) er et jokertegn, der matcher enhver streng med nul eller flere tegn. Det kan bruges som enten et præfiks eller et suffiks, og det kan også bruges i midten af ​​en streng.

Her er endnu et eksempel.

SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';

Resultat:

+-------------+------------+-------------------+
| FirstName   | LastName   | Email             |
|-------------+------------+-------------------|
| Homer       | Connery    | [email protected] |
| Bart        | Pitt       | [email protected]  |
+-------------+------------+-------------------+

Vælg fra en liste

IN operatoren bestemmer, om en specificeret værdi matcher en værdi i en underforespørgsel eller en liste.

Her er et eksempel.

SELECT 
    PetId, 
    PetName, 
    DOB 
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');

Resultat:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 4       | Wag       | 2020-03-15 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Underforespørgsler

Du kan bruge IN operator, når du udfører en underforespørgsel (en forespørgsel indlejret i en anden forespørgsel).

Her er et eksempel.

SELECT 
    PetTypeId,
    PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );

Resultat:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
+-------------+-----------+

Dette returnerede kolonner fra én tabel (PetTypes ), men kun når der var mindst én tilsvarende række i en anden tabel (Pets ), der havde et matchende PetTypeId kolonne.

For at demonstrere dette yderligere er det relevante indhold af disse to tabeller vist nedenfor.

PetTypes tabel:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+

Pets tabel:

+-------------+-----------+
| PetTypeId   | PetName   |
|-------------+-----------|
| 2           | Fluffy    |
| 3           | Fetch     |
| 2           | Scratch   |
| 3           | Wag       |
| 1           | Tweet     |
| 3           | Fluffy    |
| 3           | Bark      |
| 2           | Meow      |
+-------------+-----------+

Vi kan se, at PetTypes tabel indeholder en kæledyrstype Rabbit , men ingen af ​​kæledyrene i Pets tabel er blevet tildelt den type (dvs. der er ingen værdi af 4 i Pets.PetTypeId kolonne).

Se 12 almindeligt anvendte SQL-operatører og denne liste over SQL-operatører for at få flere oplysninger om operatører i SQL.

Deltager

Det kan diskuteres, om SQL-joins betragtes som "grundlæggende SQL-forespørgsler", men jeg vil alligevel inkludere en join her.

Så for at runde denne artikel af, er her et eksempel på en indre sammenføjning.

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

Resultat:

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

I dette tilfælde brugte vi en INNER JOIN at returnere alle kæledyrsnavne med deres respektive kæledyrstyper. Vi brugte ON klausul for at specificere prædikatet, der skal evalueres for hvert par af sammenføjede rækker. I dette tilfælde er p.PetTypeId kolonnen er en fremmednøgle til pt.PetTypeId kolonne, som er den primære nøgle til PetTypes tabel.

I dette eksempel brugte jeg også aliaser på tabellerne, hvilket var med til at holde koden pæn og kortfattet.

Se min SQL Joins Tutorial for flere eksempler på joins.


  1. Lokal midlertidig tabel i Oracle 10 (for omfanget af Stored Procedure)

  2. Dupliker, kopier eller sikkerhedskopier tabeller i MySQL, MariaDB, Oracle, PostgreSQL, DB2 og SQLite med Create Table As SQL

  3. Sådan bruger du Import/Eksport-guiden i SQL Server - SQL Server / TSQL-vejledning, del 104

  4. Enkel måde at transponere kolonner og rækker i SQL?