Samouczek SQL dla początkujących

W tym samouczku SQL dla początkujących stworzysz własną bazę danych, wstawisz do niej dane, a następnie uruchomisz zapytania do tej bazy danych.

Ten samouczek SQL pozwoli Ci błyskawicznie uruchomić zapytania SQL!

Przykład SQL

Oto przykładowa instrukcja SQL:

SELECT * 
FROM Pets;

To doskonały przykład na to, jak łatwo można pisać SQL. Ta prosta instrukcja SQL w rzeczywistości robi bardzo dużo. Zwraca całą tabelę. Zwraca wszystkie kolumny i wszystkie wiersze z tabeli o nazwie Pets .

Gwiazdka (* ) to znak wieloznaczny, co oznacza „wszystkie kolumny”. To szybki i łatwy sposób na uzyskanie wszystkich kolumn bez konieczności ich wpisywania.

To jedna z pięknych rzeczy w SQL. Najprostsze zapytania SQL są zwykle najpotężniejsze. Gdybyśmy chcieli zwrócić mniej danych, musielibyśmy napisać więcej .

Na przykład, gdybyśmy chcieli tylko zwierząt o imieniu Pobierz , dodamy WHERE klauzula, która określała ten wymóg.

Tak:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

WHERE Klauzula filtruje nasze zapytanie tylko do wierszy, w których PetName kolumna ma wartość Fetch .

To zapytanie zakłada, że istnieje kolumna o nazwie PetName oraz tabelę o nazwie Pets w bazie danych.

W tym samouczku SQL pokażę Ci, jak stworzyć taką bazę danych za pomocą SQL.

Pokażę Ci również, jak wstawiać dane do tej bazy danych, aktualizować dane, usuwać dane i uruchamiać zapytania.

Co to jest SQL?

SQL to akronim od Structured Query Language.

SQL to standardowy język zapytań używany do pracy z relacyjnymi bazami danych.

SQL jest używany przez wszystkie główne systemy zarządzania relacyjnymi bazami danych (RDBMS), w tym:

Dostęp Microsoft
Serwer SQL
Wyrocznia
PostgreSQL
MySQL
SQLite

Co mogę zrobić z SQL?

Za pomocą SQL można uruchamiać zapytania w bazie danych, wstawiać rekordy, aktualizować rekordy i usuwać rekordy. Możesz także tworzyć nowe obiekty bazy danych, takie jak bazy danych i tabele. Możesz także wykonywać zadania administracyjne bazy danych, takie jak tworzenie loginów, automatyczne zadania, kopie zapasowe bazy danych i wiele więcej.

Nawet jeśli robisz coś za pomocą graficznego interfejsu użytkownika (GUI), twój system zarządzania bazą danych (DBMS) prawie na pewno użyje SQL za kulisami do wykonania tego zadania.

Na przykład, gdy tworzysz bazę danych, klikając Utwórz bazę danych i wpisując szczegóły nowej bazy danych w oknie dialogowym, po kliknięciu OK lub Utwórz lub cokolwiek odczyta przycisk, system bazy danych użyje SQL CREATE DATABASE oświadczenie, aby kontynuować i utworzyć bazę danych zgodnie z opisem.

To samo dotyczy innych zadań, takich jak uruchamianie zapytań, wstawianie danych itp.

SQL umożliwia również wykonywanie bardziej zaawansowanych czynności, takich jak tworzenie procedur składowanych (skryptów samodzielnych), widoków (wstępnie utworzone zapytania) i ustawianie uprawnień do obiektów bazy danych (takich jak tabele, procedury składowane i widoki).

To powiedziawszy, nie musisz uczyć się wszystkich zaawansowanych rzeczy, aby zacząć korzystać z SQL. Zaletą SQL jest to, że niektóre z najczęstszych zadań są najłatwiejsze do napisania.

Standard SQL

SQL został ustandaryzowany w ANSI X3.135 w 1986 roku, aw ciągu kilku miesięcy został przyjęty przez ISO jako ISO 9075-1987. Od tego czasu międzynarodowa norma (obecnie ISO/IEC 9075) była okresowo aktualizowana i obecnie składa się z 9 części.

Większość głównych dostawców baz danych ma tendencję do przestrzegania standardu SQL. Dobrą rzeczą jest to, że nie musisz uczyć się nowego języka zapytań za każdym razem, gdy uczysz się nowego DBMS.

W praktyce jednak istnieją różnice w sposobie, w jaki każdy dostawca baz danych implementuje standard SQL. Dlatego kod, który piszesz w jednym DBMS, może nie zawsze działać w innym bez konieczności modyfikacji.

Dobrą wiadomością jest to, że wszystkie główne DBMS obsługują najpopularniejsze zadania w ten sam sposób.

Wymowa SQL

SQL jest zwykle wymawiany na dwa sposoby:

„ess-que-el ” (tj. przeliterowanie każdej litery)
„kontynuacja ” (jak w oryginalnej pisowni/wymowie).

Zobacz Czy jest to wymawiane S-Q-L lub Sequel, jeśli zastanawiasz się, dlaczego.

Czego potrzebuję do tego samouczka SQL?

Aby naprawdę skorzystać z tego samouczka SQL, powinieneś postępować zgodnie z przykładami. Oznacza to, że będziesz potrzebować miejsca, aby wprowadzić zapytania SQL. Musisz mieć coś takiego:

Jeśli zamierzasz uruchamiać zapytania SQL, będziesz potrzebować:

Zainstalowany RDBMS (taki jak SQL Server, MySQL, PostgreSQL, SQLite itp.).
Narzędzie bazy danych, które umożliwia uruchamianie zapytań SQL względem tego RDBMS (takiego jak MySQL WorkBench, Azure Data Studio (na zdjęciu), DBeaver i SSMS).

Jeśli masz już zainstalowany jeden z nich, świetnie! Możesz kontynuować samouczek.

Jeśli nie masz ich zainstalowanych, zobacz Czego potrzebuję, aby uruchomić SQL? aby uzyskać instrukcje dotyczące instalacji RDBMS i odpowiedniego narzędzia do zarządzania bazą danych, przed powrotem do tego samouczka SQL.

Utwórz bazę danych

Po zainstalowaniu systemu RDBMS i odpowiedniego narzędzia bazy danych możesz rozpocząć tworzenie bazy danych:

CREATE DATABASE PetHotel;

Zrobione!

To stwierdzenie faktycznie stworzyło bazę danych. Pusta baza danych, ale jednak baza danych.

Ta baza danych będzie zawierać tabele i dane używane w tym samouczku SQL. Kiedy tworzymy tabelę lub wstawiamy dane, zrobimy to wewnątrz tej bazy danych.

Powinienem wspomnieć, że SQLite używa innej składni do tworzenia baz danych. Jeśli używasz SQLite, oto jak utworzyć bazę danych w SQLite.

Połącz z bazą danych

Zanim zaczniesz tworzyć tabele, wstawiać dane itp., musisz upewnić się, że jesteś we właściwej bazie danych. Utworzenie bazy danych (tak jak właśnie to zrobiliśmy) niekoniecznie łączy Cię z tą bazą danych.

W wielu DBMS (takich jak SQL Server) , MySQL i MariaDB ), możemy użyć następującego, aby przełączyć się na określoną bazę danych:

USE PetHotel;

To sprawia, że PetHotel aktualna baza danych.

W SQLite , prawdopodobnie jesteś już w bazie danych po jej utworzeniu. Jeśli nie, możesz dołączyć bazę danych (która również ją utworzy, jeśli jeszcze nie istnieje):

ATTACH DATABASE 'PetHotel.db' AS Pets;

W PostgreSQL , jeśli używasz narzędzia psql, możesz użyć następującego:

\connect PetHotel

Lub wersja skrócona:

\c PetHotel

Powinienem wspomnieć, że proces tworzenia i łączenia się z bazami danych może się znacznie różnić w poszczególnych DBMS.

Na szczęście większość narzędzi GUI umożliwia łączenie się z bazą danych przez dwukrotne kliknięcie bazy danych lub kliknięcie prawym przyciskiem myszy nazwy bazy danych i wybranie nowej karty zapytania z menu kontekstowego. Jeśli utkniesz na tym etapie, po prostu użyj GUI, aby utworzyć i/lub połączyć się z bazą danych.

Utwórz tabelę

Teraz, gdy nawiązałeś połączenie z odpowiednią bazą danych, możesz iść dalej i utworzyć kilka tabel.

Aby utworzyć tabelę w SQL, użyj CREATE TABLE oświadczenie.

Tworząc tabelę, musisz określić, jakie kolumny będą się w niej znajdować, a także ich typy danych. Możesz również określić inne szczegóły, ale nie wyprzedzajmy siebie.

Stwórzmy tabelę:

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

W tym przypadku tworzymy tabelę o nazwie PetTypes . Wiemy o tym, ponieważ nazwa tabeli pojawia się bezpośrednio po CREATE TABLE fragment.

Następnie pojawia się lista kolumn, ujęta w nawiasy.

Powyższa tabela zawiera następujące kolumny:

PetIdId
PetType

Po każdej kolumnie znajduje się jej typ danych:

int oznacza, że ta kolumna akceptuje liczby całkowite. O ile mi wiadomo, większość głównych DBMS-ów obsługuje deklarowanie kolumn jako int . Jeśli masz jakiekolwiek problemy, spróbuj użyć integer .
varchar(60) oznacza, że ta kolumna akceptuje ciągi o długości do 60 znaków. varchar kolumny są ciągami o zmiennej długości. Innym typem danych ciągu jest char (który jest ciągiem o stałej długości). Jeśli masz problemy z próbą zdefiniowania kolumny jako varchar(60) , spróbuj użyć char(60) .

`NOT NULL` Ograniczenia

W tym przykładzie obie kolumny są zdefiniowane za pomocą NOT NULL ograniczenia. NOT NULL ograniczenie oznacza, że ta kolumna nie może być pusta. Po wstawieniu nowego wiersza każdy NOT NULL kolumny musi zawierać wartość. Inne kolumny mogą pozostać puste, jeśli nie ma dla nich danych.

Jeśli NULL wartości są dozwolone w kolumnie, możesz pominąć NOT NULL część lub zadeklaruj ją jako NULL (czyli NULL wartości są dozwolone w tej kolumnie).

Niektóre DBMS (takie jak DB2) nie obsługują NULL słowo kluczowe mimo wszystko, więc będziesz musiał je pominąć podczas pracy z takimi DBMS.

Klucze główne

Zrobiliśmy również PetTypeId kolumna klucz podstawowy. klucz podstawowy to co najmniej jedna kolumna, która jednoznacznie identyfikuje każdy wiersz w tabeli. Wybrane kolumny są określane jako klucz podstawowy przy użyciu ograniczenia klucza podstawowego. Możesz to zrobić w CREATE TABLE oświadczenie (tak jak zrobiliśmy to tutaj) lub możesz dodać je później za pomocą ALTER TABLE oświadczenie.

Klucze podstawowe muszą zawierać unikalne wartości. Oznacza to, że dla każdego wiersza w tej tabeli wartość w kolumnach klucza podstawowego musi być inna w każdym wierszu. Może to być tak proste, jak zwiększenie liczby (np. 1, 2, 3… itd.) lub może to być kod produktu (np. pr4650, pr2784, pr5981… itd.).

Ponadto klucze podstawowe muszą zawierać wartość. Nie może być NULL .

Chociaż klucze podstawowe nie są wymagane, ogólnie uważa się, że dobrą praktyką jest zdefiniowanie klucza podstawowego w każdej tabeli.

Utwórz więcej tabel

Utwórzmy jeszcze dwie tabele:

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

Obie te tabele są podobne do pierwszej, z wyjątkiem tego, że mają więcej rzędów i kilka dodatkowych elementów, które wyjaśnię poniżej.

Jeśli jesteś zainteresowany, sprawdź SQL CREATE TABLE for Beginners, gdzie znajdziesz kilka prostszych przykładów tworzenia tabel w SQL.

Relacje

Kiedy stworzyliśmy nasze Pets tabeli, faktycznie stworzyliśmy relację między tymi trzema tabelami.

Ta zależność jest przedstawiona na poniższym diagramie.

Relacje z bazami danych są kluczową częścią SQL. Relacje pozwalają nam wysyłać zapytania do wielu tabel o powiązane dane i uzyskiwać dokładne i spójne wyniki.

W naszym przypadku chcemy mieć możliwość wyszukiwania zwierząt według właściciela, zwierząt według typu itp. Chcemy, aby nasze wyniki były dokładne i spójne.

Aby to osiągnąć, musimy nalegać, aby wszystkie zwierzęta zostały wpisane wraz z ich właścicielem i typem. Dlatego musimy upewnić się, że za każdym razem, gdy nowy zwierzak zostanie dodany do Pets tabeli, istnieje już odpowiedni właściciel w Owners tabeli i odpowiedniego typu zwierzaka w PetTypes stół.

Zasadniczo nasze wymagania są następujące:

Dowolna wartość w Pets.PetTypeId kolumna musi odpowiadać wartości w PetTypes.PetTypeId kolumna.
Dowolna wartość w Pets.OwnerId kolumna musi odpowiadać wartości w Owners.OwnerId kolumna.

Powyższe wymagania możemy zapewnić, tworząc ograniczenie klucza obcego w odpowiednich kolumnach. klucz obcy ograniczenie służy do określenia, że dana kolumna odwołuje się do klucza głównego innej tabeli.

Powyższy kod rzeczywiście stworzył dwa ograniczenia klucza obcego dla Pets tabela.

Zauważ, że PetTypeId i OwnerId kolumny mają dodatkowy kod, który zaczyna się od REFERENCES... . To są części, które utworzyły dwa klucze obce.

Kiedy stworzyliśmy Pets tabela, jej PetTypeId kolumna ma bit, który idzie REFERENCES PetTypes (PetTypeId) . Oznacza to, że Pets.PetTypeId kolumna odwołuje się do PetTypeId kolumna w PetTypes tabela.

To samo dotyczy OwnerId kolumna. Odwołuje się do OwnerId kolumna Owners tabela.

W większości SZBD klucze obce mogą być również tworzone na istniejącej tabeli za pomocą ALTER TABLE oświadczenie, ale nie będziemy tego tutaj omawiać. Zobacz Jak utworzyć relację w SQL, aby dowiedzieć się więcej na ten temat.

W każdym razie nasze klucze obce zostały stworzone. Teraz, gdy ktoś wstawi nowego zwierzaka do Pets tabeli, PetTypeId i OwnerId wartości będą musiały mieć odpowiednią wartość w PetTypes i Owners tabele odpowiednio. Jeśli którykolwiek z nich nie, baza danych zwróci błąd.

To jest zaleta kluczy obcych. Pomaga zapobiegać wprowadzaniu złych danych. Pomaga zachować integralność danych, a dokładniej integralność referencyjną.

Sprawdź ograniczenia

Ograniczenie sprawdzania to kolejny typ ograniczenia, o którym powinieneś wiedzieć. Ograniczenie sprawdzające sprawdza dane przed wprowadzeniem ich do bazy danych. Gdy tabela ma włączone ograniczenie sprawdzania, dane mogą być wprowadzane do tabeli tylko wtedy, gdy nie narusza tego ograniczenia. Dane, które naruszają ograniczenie, nie mogą wejść do tabeli.

Na przykład możesz utworzyć ograniczenie sprawdzające dla Price kolumna, aby upewnić się, że akceptuje tylko wartości większe od zera. Lub możemy zastosować ograniczenie kontrolne do naszych Pets tabeli, aby upewnić się, że DOB kolumna nie jest w przyszłości.

Na przykład zobacz Co to jest ograniczenie SPRAWDŹ?

białe znaki

Być może zauważyłeś, że moje przykłady zawierają spacje. Na przykład rozmieściłem kod w wielu wierszach i użyłem tabulatorów do wcięcia typów danych itp.

Jest to całkowicie poprawne w SQL. Możesz to zrobić bezpiecznie i nie wpłynie to na wynik. SQL pozwala na rozłożenie kodu na wiele wierszy, jeśli chcesz, i pozwala na użycie wielu spacji lub tabulatorów w celu poprawy czytelności.

Komentarze

Możesz także umieszczać komentarze w swoim kodzie. Komentarze mogą być przydatne, gdy zaczniesz pisać dłuższe skrypty SQL. Gdy skrypt staje się dość długi, komentarze mogą ułatwić szybkie zidentyfikowanie, co robi każda część.

Komentarze w tekście

Możesz tworzyć komentarze wbudowane, poprzedzając je dwoma znakami łącznika (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

W tym przykładzie oba zapytania będą działały bez żadnych problemów. Komentarze zostaną zignorowane przez DBMS.

Komentarze wielowierszowe

Możesz rozłożyć komentarze na wiele wierszy, otaczając komentarz /* i */ :

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

W tym przykładzie oba zapytania będą działały bez żadnych problemów. Komentarze zostaną zignorowane przez DBMS.

MySQL

Jeśli używasz MySQL, możesz również użyć znaku liczby/znaku krzyżyka (# ) dla komentarzy jednowierszowych.

# This is a comment
SELECT * FROM Pets;

Komentowanie kodu

Kolejną fajną zaletą komentarzy jest możliwość komentowania kod. Na przykład, jeśli masz długi skrypt SQL, który robi wiele rzeczy, ale chcesz uruchomić tylko jedną lub dwie jego części, możesz skomentować resztę skryptu.

Oto przykład:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

W tym przypadku pierwszy SELECT instrukcja została zakomentowana, więc tylko druga SELECT instrukcja zostanie uruchomiona.

W tej technice możesz również użyć komentarzy wielowierszowych.

Wstaw dane

Teraz, gdy stworzyliśmy trzy tabele i stworzyliśmy odpowiednie klucze obce, możemy śmiało dodawać dane.

Najpopularniejszym sposobem wstawiania danych do SQL jest użycie INSERT oświadczenie. To wygląda mniej więcej tak:

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

Po prostu zastępujesz MyTable z nazwą tabeli, do której wstawiasz dane. Podobnie zastępujesz Column1 itp. z nazwami kolumn i Value1 itp. z wartościami, które trafiają do tych kolumn.

Na przykład możemy to zrobić:

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

Każda wartość jest w tej samej kolejności, w jakiej została określona kolumna.

Zwróć uwagę, że nazwy kolumn odpowiadają nazwom, których użyliśmy podczas tworzenia tabeli.

Możesz pominąć nazwy kolumn, jeśli wstawiasz dane do wszystkich kolumn. Możemy więc zmienić powyższy przykład, aby wyglądał tak:

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

W tym samouczku dodamy jeszcze kilka wierszy, więc dodamy więcej INSERT INTO oświadczenia – po jednym dla każdego wiersza, który chcemy wstawić.

Więc śmiało zapełnijmy nasze tabele.

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

Zauważ, że wypełniliśmy Pets ostatni stół. Jest ku temu powód.

Gdybyśmy próbowali wstawić dane do Pets przed wypełnieniem pozostałych dwóch, otrzymalibyśmy błąd z powodu naszego ograniczenia klucza obcego. I nie bez powodu. W końcu próbowalibyśmy wstawić wartości w kolumnach kluczy obcych, które jeszcze nie istniały w kolumnach kluczy podstawowych w innych tabelach. To duże „nie, nie”, jeśli chodzi o klucze obce.

Więc wypełniając Owners i PetTypes najpierw upewniliśmy się, że odpowiednie wartości były już w kolumnach klucza podstawowego, zanim wypełniliśmy kolumny klucza obcego w Pets tabela.

Zobacz SQL INSERT dla początkujących, aby uzyskać więcej przykładów wstawiania danych do tabel.

Sprawdź nasze dane

Uff! Wreszcie możemy rozpocząć wykonywanie zapytań w naszej bazie danych.

Sprawdźmy dane we wszystkich naszych tabelach.

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

Wynik:

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

Świetnie, więc wygląda na to, że dane zostały pomyślnie wstawione.

Wybierz określone kolumny

Powszechnie uważa się, że wybieranie wszystkich wierszy i wszystkich kolumn z tabeli jest złą praktyką (tak jak zrobiliśmy to w poprzednim przykładzie), chyba że naprawdę jest to konieczne. Może to wpłynąć na wydajność serwera bazy danych, zwłaszcza jeśli w tabeli jest dużo wierszy.

Nie stanowi to problemu, gdy używasz małych zestawów danych, takich jak my tutaj, lub jeśli jesteś w środowisku programistycznym lub podobnym. W przeciwnym razie zwykle lepiej jest wybrać tylko te kolumny, których potrzebujesz.

Dlatego, gdybyśmy chcieli identyfikatorów, imion i dat urodzenia wszystkich zwierząt, moglibyśmy to zrobić:

SELECT PetId, PetName, DOB 
FROM Pets;

Wynik:

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

Gdybyśmy chcieli identyfikatorów i daty urodzenia wszystkich zwierząt o imieniu Fluffy, moglibyśmy użyć tego:

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

Wynik:

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

Możesz także użyć SELECT instrukcja do zwrócenia danych bez tabeli. Oznacza to, że może zwrócić dane, które nie są przechowywane w tabeli. Zobacz SQL SELECT Oświadczenie dla początkujących, aby zobaczyć przykład.

Sortowanie

SQL zapewnia ORDER BY klauzula umożliwiająca nam sortowanie danych.

Możemy dodać ORDER BY klauzulę do naszego wcześniejszego przykładu, aby zwierzęta były sortowane według ich imion:

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

Wynik:

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

ASC część oznacza w górę . Kiedy używasz ORDER BY klauzula, domyślnie jest rosnąco, więc możesz pominąć ASC część, jeśli chcesz.

Aby posortować malejąco zamów, użyj DESC .

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

Wynik:

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

Możesz także sortować wyniki przy użyciu wielu kolumn. Posortuje według pierwszej określonej kolumny, a jeśli w tej kolumnie są jakieś duplikaty, posortuje te duplikaty według drugiej określonej kolumny i tak dalej.

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

Wynik:

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

Zobacz, jak dwie Puszyste zamieniły się pozycjami.

Jeśli nie używasz ORDER BY klauzuli, nie ma gwarancji, w jakiej kolejności będą wyglądać Twoje wyniki. Chociaż może to wyglądać tak jak twoja baza danych sortuje wyniki według określonej kolumny, może tak nie być. Ogólnie bez ORDER BY klauzula, dane zostaną posortowane w kolejności, w jakiej zostały załadowane do tabeli. Jeśli jednak wiersze zostały usunięte lub zaktualizowane, na kolejność będzie miało wpływ sposób, w jaki DBMS ponownie wykorzystuje odzyskaną przestrzeń dyskową.

Dlatego nie należy polegać na DBMS w sortowaniu wyników w jakiejkolwiek sensownej kolejności.

Konkluzja:jeśli chcesz, aby wyniki były posortowane, użyj ORDER BY .

Zobacz SQL ORDER BY Klauzula dla początkujących, aby uzyskać więcej przykładów.

Policz wiersze w zestawie wyników

Możesz użyć COUNT() funkcja agregująca do zliczania wierszy, które zostaną zwrócone w zapytaniu.

SELECT COUNT(*) AS Count
FROM Pets;

Wynik:

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

To mówi nam, że w tabeli jest 8 wierszy. Wiemy to, ponieważ wybraliśmy wszystkie wiersze i wszystkie kolumny.

Możesz użyć COUNT() w dowolnym zapytaniu, na przykład zapytania, które używają WHERE klauzula do filtrowania wyników.

Możesz również określić konkretną kolumnę do zliczenia. COUNT() funkcja liczy tylko wartości inne niż NULL wyniki, więc jeśli określisz kolumnę zawierającą NULL wartości, te wartości nie będą liczone.

Oto przykład, aby pokazać, o co mi chodzi.

SELECT COUNT(DOB) AS Count
FROM Pets;

Wynik:

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

Być może pamiętasz, że Pets tabela zawiera dwa NULL wartości w DOB kolumna (dwa zwierzęta nie podały daty urodzenia), więc COUNT(DOB) zwraca 6, zamiast 8, gdy użyliśmy COUNT(*) . Powód COUNT(*) zwrócił wszystkie wiersze, ponieważ te dwa wiersze zrobiły mieć dane w innych kolumnach.

W moim przykładzie mój DBMS również zwrócił ostrzeżenie o tym. Możesz otrzymać ostrzeżenie lub nie, w zależności od systemu DBMS i konkretnej konfiguracji.

Zobacz SQL COUNT dla początkujących, aby uzyskać więcej przykładów.

Inne funkcje agregujące obejmują:AVG() , SUM() , MIN() i MAX() .

Grupuj według

Inną przydatną klauzulą jest GROUP BY klauzula. To prawie tak, jak obiecuje jego nazwa. Pozwala na grupowanie wyników według danej kolumny.

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

Wynik:

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

W tym przykładzie liczymy, ile mamy zwierząt dla każdego typu zwierząt, a następnie sortujemy je w kolejności malejącej (najwyższa liczba znajduje się na górze).

Zobacz SQL GROUP BY Klauzula dla początkujących, aby uzyskać więcej przykładów.

`HAVING` Klauzula

Możemy użyć HAVING klauzula do filtrowania wyników w GROUP BY klauzula. HAVING klauzula zwraca wiersze, w których wartości zagregowane spełniają określone warunki.

Oto przykład.

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

Wynik:

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

W tym przypadku zwróciliśmy dane tylko dla typów zwierząt, które mają więcej niż 2 zwierzęta przypisane do tego typu.

Zobacz SQL HAVING Klauzula dla początkujących, aby uzyskać więcej przykładów.

Dołączenia

W SQL sprzężenie to miejsce, w którym uruchamiasz zapytanie, które łączy dane z wielu tabel.

Poprzednie dwa przykłady są w porządku, ale byłoby lepiej, gdyby zwróciły rzeczywiste typy zwierząt (np. Kot, Pies, Ptak itp.) zamiast ID (np. 1, 2, 3 itp.).

Jedynym problemem jest to, że Pets tabela nie zawiera tych danych. Te dane znajdują się w PetTypes tabela.

Na szczęście dla nas możemy połączyć te dwa stoły. Oto przykład, w którym użyto 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;

Wynik:

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

Ten zestaw wyników jest znacznie łatwiejszy do odczytania niż poprzednie. Łatwiej jest zrozumieć, ile każdego rodzaju zwierząt znajduje się w tabeli.

Składnia używa typu złączenia (w tym przypadku LEFT JOIN ), po której następuje pierwsza (lewa) tabela, po której następuje ON , po którym następuje warunek dołączenia.

Użyjmy INNER JOIN aby zwrócić wszystkie imiona zwierząt z odpowiadającymi im typami zwierząt.

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

Wynik:

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

Połączenia naprawdę otwierają nasze możliwości, ponieważ możemy teraz pobierać dane z wielu tabel i prezentować je tak, jakby były jedną tabelą.

Zauważysz, że w przykładach złączenia kwalifikujemy nazwy naszych kolumn nazwami tabel. Powodem, dla którego to robimy, jest uniknięcie niejasności dotyczących nazw kolumn kolumn między tabelami. Obie tabele mogą mieć kolumny o tej samej nazwie (jak w naszym przykładzie), a w takich przypadkach DBMS nie będzie wiedział, do której kolumny się odnosisz. Poprzedzenie nazw kolumn ich nazwami tabel gwarantuje, że odwołujesz się do właściwej kolumny i zapobiega wszelkim błędom, które mogą wynikać z jakichkolwiek niejasności co do kolumny, do której się odnosisz.

Zobacz mój samouczek SQL Joins, aby uzyskać więcej przykładów i wyjaśnienie różnych typów złączeń.

Aliasy

Możemy pójść o krok dalej i przypisać alias do każdej nazwy tabeli i nazwy kolumny.

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

Wynik:

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

Doprowadziło to do powstania nowych nagłówków kolumn, a kod jest bardziej zwięzły.

Alias umożliwia tymczasowe przypisanie innej nazwy do tabeli lub kolumny na czas trwania SELECT zapytanie. Może to być szczególnie przydatne, gdy tabele i/lub kolumny mają bardzo długie lub złożone nazwy.

Alias jest przypisywany za pomocą AS słowo kluczowe, chociaż to słowo kluczowe jest opcjonalne, więc można je bezpiecznie pominąć. Zwróć uwagę, że Oracle nie obsługuje AS słowo kluczowe w aliasach tabel (ale tak w aliasach kolumn).

W powyższym przykładzie umieściłem AS słowo kluczowe podczas przypisywania aliasów kolumn, ale pominięto je podczas przypisywania aliasów tabeli.

Nazwa aliasu może być dowolna, ale zwykle jest krótka dla celów czytelności.

W naszym przypadku zmieniliśmy dwie tabele na p i pt , a nazwy kolumn do Pet i Pet Type . Zauważ, że otoczyłem Pet Type w podwójnych cudzysłowach. Zrobiłem to, bo w nazwie jest spacja. W przypadku aliasów bez spacji nie musisz tego robić. W SQL Server można alternatywnie używać nawiasów kwadratowych ([] ) zamiast podwójnych cudzysłowów (chociaż obsługuje również podwójne cudzysłowy).

Praktyka używania spacji w kolumnach i aliasach jest generalnie odradzana, ponieważ może powodować różnego rodzaju problemy z niektórymi aplikacjami klienckimi.

Zauważ, że nadal musieliśmy używać pełnych nazw kolumn podczas odwoływania się do nich w łączeniu (po ON słowo kluczowe).

Powinienem zaznaczyć, że przypisanie aliasu w rzeczywistości nie zmienia nazwy kolumny lub tabeli.

Zobacz wyjaśnienie aliasu SQL, aby uzyskać więcej przykładów.

Aktualizacja danych

Możesz użyć UPDATE oświadczenie, aby zaktualizować dane w tabelach.

Podstawowa składnia jest dość prosta:

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

W tym przykładzie aktualizujemy LastName kolumna, aby otrzymać nową wartość Stallone gdzie OwnerId to 3 .

Aby zaktualizować wiele kolumn, użyj przecinka, aby oddzielić każdą parę kolumna/wartość.

Ale cokolwiek robisz, nie zapomnij WHERE klauzula (chyba że faktycznie zamierzasz zaktualizować każdy wiersz w tabeli o tej samej wartości).

Zobacz SQL UPDATE dla początkujących, aby uzyskać więcej przykładów i bardziej szczegółowe wyjaśnienie.

Usuwanie danych

Możesz użyć DELETE oświadczenie, aby usunąć dane z tabel.

Podstawowa składnia jest jeszcze prostsza niż UPDATE oświadczenie:

DELETE FROM Owners
WHERE OwnerId = 5;

Tutaj usuwamy właściciela numer 5 z Owners tabela.

Podobnie jak w przypadku UPDATE oświadczenie, nie zapomnij WHERE klauzula (chyba że zamierzasz usunąć każdy wiersz w tabeli ).

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

Operatory SQL

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. Elementy danych nazywane są operandami lub argumenty . 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 składnia.

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.

Wynik:

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

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;

Wynik:

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

EXEC uspGetPetById @PetId = 3;

Wynik:

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

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

Samouczek SQL dla początkujących

Przykład SQL

Co to jest SQL?

Co mogę zrobić z SQL?

Standard SQL

Wymowa SQL

Czego potrzebuję do tego samouczka SQL?

Utwórz bazę danych

Połącz z bazą danych

Utwórz tabelę

NOT NULL Ograniczenia

Klucze główne

Utwórz więcej tabel

Relacje

Sprawdź ograniczenia

białe znaki

Komentarze

Komentarze w tekście

Komentarze wielowierszowe

MySQL

Komentowanie kodu

Wstaw dane

Sprawdź nasze dane

Wybierz określone kolumny

Sortowanie

Policz wiersze w zestawie wyników

Grupuj według

HAVING Klauzula

Dołączenia

Aliasy

Aktualizacja danych

Usuwanie danych

Dropping Objects

Operatory SQL

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` Ograniczenia

`HAVING` Klauzula