sql >> Database >  >> RDS >> Sqlserver

Een query maken in SQL Server 2017

Een query maken in een SQL Server 2017-database.

Een van de meest elementaire vragen die u kunt doen, gaat als volgt:

SELECT * 
FROM TableName;

Deze query retourneert alle gegevens uit een bepaalde tabel. TableName is de naam van de tabel die u wilt opvragen. Het enige dat u hoeft te doen, is deze te vervangen door de naam van een tabel in uw database, de query uit te voeren en de inhoud van die tabel wordt weergegeven.

Onze database bestaat uit drie tabellen. Elk bevat gegevens. Laten we eens kijken wat er in elke tabel staat.

De Artists tafel:

SELECT * 
FROM Artists;
Resultaat
ArtistId  ArtistName              ActiveFrom              
--------  ----------------------  ------------------------
1         Iron Maiden             1975-12-25T00:00:00.000Z
2         AC/DC                   1973-01-11T00:00:00.000Z
3         Allan Holdsworth        1969-01-01T00:00:00.000Z
4         Buddy Rich              1919-01-01T00:00:00.000Z
5         Devin Townsend          1993-01-01T00:00:00.000Z
6         Jim Reeves              1948-01-01T00:00:00.000Z
7         Tom Jones               1963-01-01T00:00:00.000Z
8         Maroon 5                1994-01-01T00:00:00.000Z
9         The Script              2001-01-01T00:00:00.000Z
10        Lit                     1988-06-26T00:00:00.000Z
11        Black Sabbath           1968-01-01T00:00:00.000Z
12        Michael Learns to Rock  1988-03-15T00:00:00.000Z
13        Carabao                 1981-01-01T00:00:00.000Z
14        Karnivool               1997-01-01T00:00:00.000Z
15        Birds of Tokyo          2004-01-01T00:00:00.000Z
16        Bodyjar                 1990-01-01T00:00:00.000Z

16 row(s) returned

Executed in 1 ms

De Albums tafel:

SELECT * 
FROM Albums;
Resultaat
AlbumId  AlbumName                 ReleaseDate               ArtistId  GenreId
-------  ------------------------  ------------------------  --------  -------
1        Powerslave                1984-09-03T00:00:00.000Z  1         1      
2        Powerage                  1978-05-05T00:00:00.000Z  2         1      
3        Singing Down the Lane     1956-01-01T00:00:00.000Z  6         3      
4        Ziltoid the Omniscient    2007-05-21T00:00:00.000Z  5         1      
5        Casualties of Cool        2014-05-14T00:00:00.000Z  5         1      
6        Epicloud                  2012-09-18T00:00:00.000Z  5         1      
31       Somewhere in Time         1986-09-29T00:00:00.000Z  1         1      
32       Piece of Mind             1983-05-16T00:00:00.000Z  1         1      
33       Killers                   1981-02-02T00:00:00.000Z  1         1      
34       No Prayer for the Dying   1990-10-01T00:00:00.000Z  1         1      
35       No Sound Without Silence  2014-09-12T00:00:00.000Z  9         4      
36       Big Swing Face            1967-06-01T00:00:00.000Z  4         2      
37       Blue Night                2000-11-01T00:00:00.000Z  12        4      
38       Eternity                  2008-10-27T00:00:00.000Z  12        4      
39       Scandinavia               2012-06-11T00:00:00.000Z  12        4      
40       Long Lost Suitcase        2015-10-09T00:00:00.000Z  7         4      
41       Praise and Blame          2010-06-26T00:00:00.000Z  7         4      
42       Along Came Jones          1965-05-21T00:00:00.000Z  7         4      
43       All Night Wrong           2002-05-05T00:00:00.000Z  3         2      
44       The Sixteen Men of Tain   2000-03-20T00:00:00.000Z  3         2      

20 row(s) returned

Executed in 1 ms

De Genres tafel:

SELECT * 
FROM Genres;
Resultaat
GenreId  Genre  
-------  -------
1        Rock   
2        Jazz   
3        Country
4        Pop    
5        Blues  
6        Hip Hop
7        Rap    
8        Punk   

8 row(s) returned

Executed in 1 ms

In alle drie de gevallen was onze vraag hetzelfde. Het enige dat veranderde was de tafelnaam.

Dit is een van de meest elementaire vragen die we kunnen doen. Het retourneert eenvoudig alle rijen en alle kolommen uit een enkele tabel.

We kunnen deze query op een aantal manieren wijzigen om alleen de gegevens te retourneren die we willen zien. Hieronder staan ​​enkele veelvoorkomende manieren waarop we een zoekopdracht kunnen aanpassen om precies de resultaten te krijgen die we nodig hebben.

Geef de kolommen op

In plaats van het sterretje (* ) om alle kolommen te retourneren, kunt u expliciet alleen die kolommen aangeven die u wilt retourneren.

SELECT AlbumId, AlbumName, ArtistId 
FROM Albums;
Resultaat
AlbumId  AlbumName                 ArtistId
-------  ------------------------  --------
1        Powerslave                1       
2        Powerage                  2       
3        Singing Down the Lane     6       
4        Ziltoid the Omniscient    5       
5        Casualties of Cool        5       
6        Epicloud                  5       
31       Somewhere in Time         1       
32       Piece of Mind             1       
33       Killers                   1       
34       No Prayer for the Dying   1       
35       No Sound Without Silence  9       
36       Big Swing Face            4       
37       Blue Night                12      
38       Eternity                  12      
39       Scandinavia               12      
40       Long Lost Suitcase        7       
41       Praise and Blame          7       
42       Along Came Jones          7       
43       All Night Wrong           3       
44       The Sixteen Men of Tain   3       

20 row(s) returned

Executed in 1 ms

Beperk de criteria

U kunt een WHERE . toevoegen clausule om alleen die rijen te retourneren die voldoen aan een door u verstrekt criterium.

SELECT AlbumId, AlbumName, ArtistId 
FROM Albums 
WHERE ArtistId = 1;
Resultaat
AlbumId  AlbumName                ArtistId
-------  -----------------------  --------
1        Powerslave               1       
31       Somewhere in Time        1       
32       Piece of Mind            1       
33       Killers                  1       
34       No Prayer for the Dying  1       

5 row(s) returned

Executed in 1 ms

Deelnemen aan een andere tafel

U kunt een join gebruiken om resultaten te retourneren van meerdere tabellen die gegevens delen. Dit is waar relaties over gaan. In het bijzonder wordt een join meestal gebruikt wanneer de externe sleutel van de ene tabel overeenkomt met de primaire sleutel van een andere.

SELECT AlbumId, AlbumName, ArtistName 
FROM Albums 
	INNER JOIN Artists 
	ON Albums.ArtistId = Artists.ArtistId 
WHERE ReleaseDate < '1980-01-01';
Resultaat
AlbumId  AlbumName              ArtistName
-------  ---------------------  ----------
2        Powerage               AC/DC     
3        Singing Down the Lane  Jim Reeves
36       Big Swing Face         Buddy Rich
42       Along Came Jones       Tom Jones 

4 row(s) returned

Executed in 1 ms

Je zult zien dat de WHERE clausule werkt nog steeds op kolommen die niet echt in de uitvoer zijn opgenomen. In dit geval werd het toegepast op de ReleaseDate kolom, ook al nemen we die kolom niet op in de resultaten.

U zult ook zien dat we de twee ArtistId . kwalificeren kolommen met de naam van de tabel (bijv. Albums.ArtistId en Artists.ArtistId ). We moeten dit doen zodat SQL Server weet naar welke tabel we verwijzen wanneer we naar die kolom verwijzen. Sommige databaseontwikkelaars beschouwen het als een goede gewoonte om alle kolomnamen in alle SQL-query's te kwalificeren, maar dit is meer een geval van persoonlijke voorkeur of projectspecifieke coderingsconventie.

Een alias toevoegen

U kunt ook tabelaliassen aan uw query's toevoegen om de code beknopter te maken. U kunt bijvoorbeeld Artists . geven een alias van ar en Albums een alias van al (of een andere string die je leuk vindt).

U kunt deze aliassen gebruiken om de kolomnamen te kwalificeren. Hier is dezelfde zoekopdracht als hierboven, maar met alle kolomnamen gekwalificeerd met tabelaliassen:

SELECT al.AlbumId, al.AlbumName, ar.ArtistName 
FROM Albums al
	INNER JOIN Artists ar
	ON al.ArtistId = ar.ArtistId 
WHERE al.ReleaseDate < '1980-01-01';
Resultaat
AlbumId  AlbumName              ArtistName
-------  ---------------------  ----------
2        Powerage               AC/DC     
3        Singing Down the Lane  Jim Reeves
36       Big Swing Face         Buddy Rich
42       Along Came Jones       Tom Jones 

4 row(s) returned

Executed in 1 ms

U kunt ook aliassen toewijzen aan kolommen (niet alleen tabellen). We doen dit in het volgende voorbeeld.

Maak de datum op

Er zijn veel verschillende manieren waarop datums en tijden in databases kunnen worden verwerkt. In SQL Server zijn er verschillende gegevenstypen voor het opslaan van datums (zoals date , time , datetime , smalldatetime , etc) en er zijn veel verschillende functies voor het omgaan met datums (bijvoorbeeld SYSDATETIME() , GETDATE( ) , CURRENT_TIMESTAMP , enz.).

In dit voorbeeld gebruiken we de YEAR() functie om alleen het jaargedeelte van de datum terug te geven.

SELECT AlbumName, YEAR(ReleaseDate) AS Year 
FROM Albums;
Resultaat
AlbumName                 Year
------------------------  ----
Powerslave                1984
Powerage                  1978
Singing Down the Lane     1956
Ziltoid the Omniscient    2007
Casualties of Cool        2014
Epicloud                  2012
Somewhere in Time         1986
Piece of Mind             1983
Killers                   1981
No Prayer for the Dying   1990
No Sound Without Silence  2014
Big Swing Face            1967
Blue Night                2000
Eternity                  2008
Scandinavia               2012
Long Lost Suitcase        2015
Praise and Blame          2010
Along Came Jones          1965
All Night Wrong           2002
The Sixteen Men of Tain   2000

20 row(s) returned

Executed in 1 ms

In dit voorbeeld kennen we ook een alias toe aan een kolom. Meer specifiek kennen we een alias toe aan het resultaat van de YEAR() functie, waarvan we de ReleaseDate . doorgeven kolom als argument.

Een ander punt over dit voorbeeld is dat we de AS . hebben gebruikt trefwoord bij het toewijzen van de alias. Dit is optioneel en we hadden ook de AS . kunnen gebruiken trefwoord bij het toewijzen van een alias aan een tabel in het vorige voorbeeld.

Over SQL en Transact-SQL

De bovenstaande queries (en de andere queries in deze tutorial) zijn geschreven in Structured Query Language (SQL). Meer specifiek gebruikt SQL Server Transact-SQL (soms afgekort tot T-SQL ), de eigen extensie van Microsoft en Sybase voor SQL.

SQL is de standaard zoektaal die wordt gebruikt op de meeste relationele databasebeheersystemen. Het is een norm van het American National Standards Institute (ANSI) en van de International Organization for Standardization (ISO).

Hoewel de meeste basisquery's in de meeste relationele databases werken, moeten sommige query's mogelijk enigszins worden gewijzigd bij het overzetten tussen het ene databasesysteem en het andere. U hebt bijvoorbeeld een script dat in SQL Server wordt uitgevoerd. Je zou dat script ook in MySQL kunnen gebruiken, maar het kan zijn dat je een paar dingen moet veranderen voordat het succesvol kan worden uitgevoerd.

De SQL-scripts in deze zelfstudie demonstreren slechts een klein voorbeeld van wat u met SQL kunt doen. Bekijk voor meer informatie mijn SQL-zelfstudie of ga naar de Microsoft Transact-SQL-referentie.


  1. SQL Row_Number() functie in Where-clausule

  2. Django cache.set() veroorzaakt dubbele sleutelfout

  3. hoe het type waarde in postgres te controleren

  4. Verbinding maken met SQL Server LocalDB met behulp van JDBC