Sqlserver
 sql >> Baza danych >  >> RDS >> Sqlserver

Utwórz zapytanie w SQL Server 2017

Jak utworzyć zapytanie w bazie danych SQL Server 2017.

Jedno z najbardziej podstawowych zapytań, które możesz wykonać, brzmi tak:

SELECT * 
FROM TableName;

To zapytanie zwraca wszystkie dane z danej tabeli. TableName to nazwa tabeli, do której chcesz wykonać zapytanie. Wszystko, co musisz zrobić, to zastąpić ją nazwą tabeli w bazie danych, uruchomić zapytanie, a zawartość tej tabeli zostanie wyświetlona.

Nasza baza danych składa się z trzech tabel. Każdy zawiera dane. Zobaczmy, co jest w każdej tabeli.

Artists tabela:

SELECT * 
FROM Artists;
Wynik
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

Albums tabela:

SELECT * 
FROM Albums;
Wynik
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

Genres tabela:

SELECT * 
FROM Genres;
Wynik
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

We wszystkich trzech przypadkach nasze zapytanie było takie samo. Jedyną rzeczą, która się zmieniła, była nazwa stołu.

To jedno z najbardziej podstawowych zapytań, jakie możemy wykonać. Po prostu zwraca wszystkie wiersze i wszystkie kolumny z jednej tabeli.

Możemy zmodyfikować to zapytanie na wiele sposobów, aby zwrócić tylko te dane, które chcemy zobaczyć. Poniżej znajduje się kilka typowych sposobów modyfikowania zapytania, aby zwracało dokładnie te wyniki, których potrzebujemy.

Określ kolumny

Zamiast używać gwiazdki (* ), aby zwrócić wszystkie kolumny, możesz wyraźnie określić tylko te kolumny, które chcesz zwrócić.

SELECT AlbumId, AlbumName, ArtistId 
FROM Albums;
Wynik
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

Zawęź kryteria

Możesz dodać WHERE klauzula, aby zwrócić tylko te wiersze, które spełniają podane przez Ciebie kryteria.

SELECT AlbumId, AlbumName, ArtistId 
FROM Albums 
WHERE ArtistId = 1;
Wynik
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

Dołącz do innego stołu

Możesz użyć sprzężenia, aby zwrócić wyniki z wielu tabel, które współużytkują dane. O to właśnie chodzi w związkach. W szczególności sprzężenie jest zwykle używane, gdy klucz obcy jednej tabeli pasuje do klucza podstawowego innej tabeli.

SELECT AlbumId, AlbumName, ArtistName 
FROM Albums 
	INNER JOIN Artists 
	ON Albums.ArtistId = Artists.ArtistId 
WHERE ReleaseDate < '1980-01-01';
Wynik
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

Zobaczysz, że WHERE Klauzula nadal działa na kolumnach, które nie są w rzeczywistości uwzględnione w danych wyjściowych. W tym przypadku został zastosowany do ReleaseDate kolumna, nawet jeśli nie uwzględniamy tej kolumny w wynikach.

Zobaczysz również, że kwalifikujemy dwa ArtistId kolumny z nazwą tabeli (np. Albums.ArtistId i Artists.ArtistId ). Musimy to zrobić, aby SQL Server wiedział, do której tabeli odwołujemy się podczas odwoływania się do tej kolumny. Niektórzy programiści baz danych uważają za dobrą praktykę kwalifikowanie wszystkich nazw kolumn we wszystkich zapytaniach SQL, jednak jest to bardziej przypadek osobistych preferencji lub konwencji kodowania specyficznej dla projektu.

Dodaj alias

Możesz również dodać aliasy tabel do zapytań, aby kod był bardziej zwięzły. Na przykład możesz dać Artists alias ar i Albums alias al (lub dowolny inny ciąg, który lubisz).

Możesz użyć tych aliasów do zakwalifikowania nazw kolumn. Oto to samo zapytanie co powyżej, ale ze wszystkimi nazwami kolumn kwalifikowanymi aliasami tabeli:

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

Możesz także przypisać aliasy do kolumn (nie tylko tabel). Zrobimy to w następnym przykładzie.

Sformatuj datę

Istnieje wiele różnych sposobów traktowania dat i godzin w bazach danych. W SQL Server istnieją różne typy danych do przechowywania dat (takie jak date , time , datetime , smalldatetime , itp.) i istnieje wiele różnych funkcji do radzenia sobie z datami (na przykład SYSDATETIME() , GETDATE( ) , CURRENT_TIMESTAMP itp.).

W tym przykładzie użyjemy YEAR() funkcja zwraca tylko część roku w dacie.

SELECT AlbumName, YEAR(ReleaseDate) AS Year 
FROM Albums;
Wynik
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

W tym przykładzie przypisujemy również alias do kolumny. Dokładniej, przypisujemy alias wynikowi YEAR() funkcję, której przekazujemy ReleaseDate kolumna jako argument.

Inną kwestią dotyczącą tego przykładu jest to, że użyliśmy AS słowo kluczowe podczas przypisywania aliasu. Jest to opcjonalne i mogliśmy również użyć AS słowo kluczowe podczas przypisywania aliasu do tabeli w poprzednim przykładzie.

O SQL i Transact-SQL

Powyższe zapytania (i inne zapytania w tym samouczku) są napisane w Structured Query Language (SQL). Dokładniej, SQL Server używa języka Transact-SQL (czasami skracane do T-SQL ), które jest zastrzeżonym rozszerzeniem SQL firmy Microsoft i Sybase.

SQL to standardowy język zapytań używany w większości systemów zarządzania relacyjnymi bazami danych. Jest to standard Amerykańskiego Narodowego Instytutu Normalizacyjnego (ANSI) oraz Międzynarodowej Organizacji Normalizacyjnej (ISO).

Podczas gdy większość podstawowych zapytań będzie działać w większości relacyjnych baz danych, niektóre zapytania mogą wymagać nieznacznej modyfikacji podczas przenoszenia między jednym systemem baz danych a drugim. Na przykład możesz mieć skrypt, który działa w programie SQL Server. Możesz również użyć tego skryptu w MySQL, jednak może się okazać, że będziesz musiał zmienić kilka rzeczy, zanim zostanie pomyślnie uruchomiony.

Skrypty SQL w tym samouczku demonstrują tylko małą próbkę rzeczy, które można zrobić za pomocą SQL. Aby uzyskać więcej informacji, zapoznaj się z moim samouczkiem SQL lub przejdź do Microsoft Transact-SQL Reference.


  1. Database
  2.   
  3. Mysql
  4.   
  5. Oracle
  6.   
  7. Sqlserver
  8.   
  9. PostgreSQL
  10.   
  11. Access
  12.   
  13. SQLite
  14.   
  15. MariaDB
  1. Jak wyświetlić sortowanie serwerów w programie SQL Server (T-SQL)

  2. Operator ampersand (&) w SQL Server klauzula WHERE

  3. Uzupełnianie brakujących dat według grup

  4. Jak zmienić kolumnę z wartości Null na Not Null w tabeli SQL Server — samouczek SQL Server / T-SQL, część 52

  5. Radzenie sobie z błędami o wysokim stopniu ważności w SQL Server