Narzędzia użytkownika

Narzędzia witryny


materialy:podstawy-administracji:sql

SQL

Wstęp

Administrator wcześniej czy później napotka potrzebę zarządzania i korzystania z bazy danych. Poniżej przedstawione zagadnienia omawiają jedynie podstawy języka zapytań SQL pomijając kwestie administracji samą instancją baz danych (kontenerem zawierającym wiele baz danych). Jest wiele usług, które z racji szybkości przetwarzania informacji przechowują swoje dane w bazach SQL (np. zaawansowany system Open Source do backupu - Bacula). Dzięki znajomości podstaw języka SQL można zajrzeć do źródła danych z których korzysta program, budować własne raporty na podstawie zawartych w bazie informacji, można szybciej rozwiązywać problemy w kontekście danych zawartych w bazie a przede wszystkim można swobodniej zarządzać programami i systemami, które z baz danych korzystają.

W poniższym poradniku zakładamy, że w systemie nie ma zainstalowanego żadnego silnika obsługi baz danych. Zaczynamy od instalacji instancji bazodanowej, później utworzymy przykładową bazę danych aby wypełnić ją danymi a na końcu generować raporty - wyciągać z niej informacje. Dzięki temu poradnikowi poznasz podstawy uniwersalnego języka zapytań SQL.

Instalacja serwera MySQL i wstępna konfiguracja na przykładzie CentOS

Ćwiczenia z SQL można rozpocząć z dowolnym silnikiem baz danych SQL. W Linux najpopularniejszym darmowym silnikiem jest MySQL.

Instalacja:

yum install mysql mysql-server

Uruchomienie serwisu oraz skonfigurowanie go, aby startował wraz z uruchomianiem systemu:

service mysqld start
chkconfig --levels 235 mysqld on

Ustawienie hasła lpilpi dla użytkownika root instancji bazy danych (instancja SQL posiada własny zestaw loginów i haseł niezależny od systemu operacyjnego):

mysqladmin -u root password 'lpilpi'

Instalacja serwera MySQL i wstępna konfiguracja na przykładzie Debian

Instalacja i konfiguracja:

apt-get install mysql-server

Instalator:

  • pobierze odpowiednie paczki instalacyjne;
  • zainstaluje oprogramowanie;
  • poprosi administratora o ustanowienie hasła dla konta root na serwerze MySQL (to nie jest konto systemowe tylko konto instancji bazy danych);
  • uruchomi serwis mysql;
  • oznaczy serwis mysql jako ten, który ma być uruchamiany przy starcie systemu.

Logowanie do silnika baz danych i pierwsze komendy

Aby wykonywać jakiekolwiek operacje na instancji baz danych należy się do niej zalogować. Instancje baz danych mają najczęściej wewnętrzną, własną obsługę uwierzytelniania. Niezależnie od kont systemowych należy na instancji baz danych tworzyć osobne konta z własnymi hasłami (które są najczęściej przechowywane w odpowiedniej bazie danych). Ponieważ nie tworzyliśmy żadnego innego konta użytkownika na instancji, do testów będziemy używać konta root kreowanego automatycznie podczas instalacji. Należy pamiętać, że takie podejście nie jest to polecane na środowiskach produkcyjnych, ale w zupełności wystarczające do nauki na środowiskach testowych.

Po tym, jak dla konta root zostało utworzone hasło można zalogować się do lokalnego serwera sql na konto root:

mysql -u root -p

Aplikacja zapyta w kolejnym kroku jakie jest hasło do konta root.

Można również jawnie w samej komendzie podać hasło, choć należy pamiętać, że komenda ta (z hasłem) zapisze się w historii komend użytkownika.

mysql -u root -plpilpi

Po zalogowaniu pojawia się prompnt mysql> za którym można podawać komendy języka SQL jak i komendy samego silnika bazy danych MySQL. Aby uzyskać pomoc można użyć komendy help, której argumentem może być dowolna komenda, np:

help SELECT

Aby wyjść z konsoli mysql należy użyć polecenia exit.

Jedne z pierwszych komend uruchamianych na nowej instancji lub po zarejestrowaniu i zalogowaniu nowego użytkownika to:

  • Wyświetlenie listy baz danych na instancji:
    SHOW databases;
  • Wyświetlenie nazwy użytkownika w kontekście którym są wykonywane komendy sql
    SELECT user();
  • Wyświetlenie wersji serwera MySQL:
    SELECT version();

Aby wyświetlić listę tabel określonej bazy danych, na przykład bazy mysql:

mysql> USE mysql; show tables;

Proszę zwrócić uwagę, że każda komenda SQL kończy się średnikiem - ;. Jeśli podczas wpisywania komendy naciśniemy ENTER, kursor przejdzie do nowej linii, jednak treść komendy może być dalej wpisywana i będzie interpretowana dopóki nie będzie znaku średnika.

Baza dla backupów - analiza przypadku

Założenia

Dalsze przykłady oparte są na analizie przypadku przygotowania bazy danych wspomagającej aplikację do wykonywania backupu. Baza danych będzie zawierała kilka tabel:

  • dwie tabele słownikowe, zawierające:
    • możliwe częstotliwości wykonywania backupów - co godzinę, co dzień, co tydzień, co miesiąc;
    • możliwe typy wykonywania backupów - pełny, przyrostowy, różnicowy.
  • jedną główną tabelę zawierającą ścieżki do folderów lub plików, które mają być backupowane oraz dla każdego wpisu informacje o tym jak często ma być backup wykonywany, jakiego typu to ma być backup i kiedy ostatnio był wykonywany.

Utworzenie odseparowanej bazy danych

Jedna instanacja/silnik bazodanowy obsługuje nie jedną a wiele aplikacji jednocześnie. Każda z aplikacji korzystających z tego samego silnika baz danych winna mieć odseparowane środowisko w którym dane są przechowywane. Takim środowiskiem jest - baza danych.

Aby utworzyć bazę danych, np. o nazwie systembackupu należy wywołać:

mysql> CREATE DATABASE systembackupu;

Utworzenie dedykowanego konta w bazie danych do obsługi bazy

W praktyce użytkownik korzysta ze skryptu, aplikacji bądź serwisu, który dopiero zagląda do bazy danych i wykonuje na niej odpowiednie operacje. Aby to pośredniczące między użytkownikiem a bazą danych oprogramowanie nie miało zbyt dużych uprawnień na instancji baz danych powinno mieć dostęp tylko do wybranej bazy lub określonych tabel w tej bazie. Zawężenie uprawnień można realizować poprzez utworzenie dedykowanego konta oraz nadanie mu odpowiednich uprawnień.

W naszym przypadku utworzymy konto o nazwie backup z hasłem mojehaslo (poniższe komendy należy wykonać w kontekście administratora instancji MySQL - roota):

mysql> CREATE USER 'backup' IDENTIFIED BY 'mojehaslo';

Aby nadać użytkownikowi backup pełne uprawnienia do wcześniej utworzonej bazy systembackupu:

mysql> GRANT ALL PRIVILEGES ON systembackupu.* TO 'backup' WITH GRANT OPTION;
mysql> FLUSH PRIVILEGES;

Następnie należy wylogować się z konta administracyjnego MySQL i zalogować na konto backup:

mysql> exit
Linux$ mysql -u backup -pmojehaslo

Funkcja informacyjna CURRENT_USER() wskaże nazwę użytkownika w kontekście którego pracujemy:

mysql> SELECT CURRENT_USER();

Aby dalsze prace wykonywać w kontekście tej bazy danych, należy ją wskazać w instrukcji USE:

mysql> USE systembackupu;

Tworzenie tablic słownikowych i ich modyfikacja - CREATE, INSERT, UPDATE, DELETE

Utwórzmy definicję tabeli słownikowej o nazwie jakczesto - tabela będzie zawierała wszystkie możliwe przypadki częstotliwości wykonywania backupów zgodnie z założeniami - co godzinę, co dzień, co tydzień, co miesiąc. Zanim jednak tabela będzie wypełniona tymi wpisami trzeba ją utworzyć. Przy tworzeniu trzeba określić jej strukturę, czyli podać ile będzie miała kolumn i jakiego typu dane będą w każdej kolumnie. Ponieważ jest to tabela słownikowa wydaje się, że wystarczy jedna kolumna z wpisami tekstowymi „co godzinę”, „co dzień” itd. Dobrze jednak w tablicach słownikowych i zgodnie z regułami budowania relacyjnych baz danych dodać kolumnę identyfikatora, za pomocą którego łatwiej będzie odnosić się do elementów tej tabeli.

mysql> CREATE TABLE jakczesto (
    -> id INT NOT NULL AUTO_INCREMENT,
    -> nazwa VARCHAR(10),
    -> PRIMARY KEY (id)
    -> );

Definicja tabeli zawiera listę 2 kolumn, które się w niej znajdują. Kolumna o nazwie id:

  • jest typu INT - liczba całkowita;
  • jest kluczem głównym tabeli (PRIMARY KEY) - jej wartość jest unikalna dla każdego wiersza tabeli i jednoznacznie ten wiersz identyfikuje;
  • ma przypisane atrybut NOT NULL - nie może mieć pustych wpisów;
  • ma przypisany atrybut AUTO_INCREMENT - wiersze tabeli będą miały automatycznie przypisywany kolejną liczbę;

Kolumna nazwa jest typu znakowego (VARCHAR) o maksymalnej długości 10 znaków.

Aby wyświetlić strukturę istniejącej tabeli użyj komendy DESC

DESC jakczesto;

Aby dodać do tabeli wartości, należy użyć zapytania INSERT INTO:

mysql> INSERT INTO jakczesto VALUES (1, "co godzine");
mysql> INSERT INTO jakczesto (nazwa) VALUES ("co dzien");
mysql> INSERT INTO jakczesto (nazwa) VALUES ("tygodniowo"), ("co miesiac"), ("co rok");

W drugiej i trzeciej instrukcji nie podajemy wartości dla kolumny id, gdyż kolumna ma atrybut AUTO_INCREMENT - wartość zostanie automatycznie przypisana (o jeden większa od ostatnio używanej). Jeśli w wartościach nie są podawane wartości dla wszystkich kolumn trzeba jednak za nazwą tabeli zadeklarować jakie kolumny będą wypełniane - w powyższych przypadkach tylko kolumna nazwa. Ostatnia komenda jest przykładem dodania kilku wierszy w jednej komendzie SQL.

Wyświetlenie wszystkich wierszy i wszystkich kolumn z określonej tabeli można wykonać za pomocą najpopularniejszej komendy dla języka zapytań SQL SELECT * FROM tabela;:

mysql> SELECT * FROM jakczesto;
+----+------------+
| id | nazwa      |
+----+------------+
|  1 | co godzine |
|  2 | co dzien   |
|  3 | tygodniowo |
|  4 | co miesiac |
|  5 | co rok     |
+----+------------+

Za instrukcją SELECT podajemy nazwy kolumn do wyświetlania - gwiazdka oznacza wszystkie kolumny. Jeśli mają być wyświetlane tylko wybrane kolumny lub w zdefiniowanej kolejności:

mysql> SELECT nazwa FROM jakczesto;
+------------+
| nazwa      |
+------------+
| co godzine |
| co dzien   |
| tygodniowo |
| co miesiac |
| co rok     |
+------------+
 
mysql> SELECT nazwa,id FROM jakczesto;
+------------+----+
| nazwa      | id |
+------------+----+
| co godzine |  1 |
| co dzien   |  2 |
| tygodniowo |  3 |
| co miesiac |  4 |
| co rok     |  5 |
+------------+----+

Jeśli chcemy usunąć z tabeli określone wiersze - w założeniach nie było częstotliwości co rok, należy użyć instrukcji DELETE a instrukcją WHERE określić, które wiersze mają być usunięte. Poniżej przykład usunięcia z używanej tabeli wierszy, których kolumna nazwa ma wartość „co rok”;

mysql> DELETE FROM jakczesto WHERE nazwa="co rok";

Po skasowaniu wiersza nie powinien on być wyświetlany przy poniższej komendzie:

mysql> SELECT * FROM jakczesto;
+----+------------+
| id | nazwa      |
+----+------------+
|  1 | co godzine |
|  2 | co dzien   |
|  3 | tygodniowo |
|  4 | co miesiac |
+----+------------+

Załóżmy, że chcemy poprawić nazwę dla wiersza nr 3 z tygodniowo na co tydzien:

mysql> UPDATE jakczesto SET nazwa="co tydzien" WHERE nazwa="tygodniowo";

Od teraz:

mysql> SELECT * FROM jakczesto;
+----+------------+
| id | nazwa      |
+----+------------+
|  1 | co godzine |
|  2 | co dzien   |
|  3 | co tydzien |
|  4 | co miesiac |
+----+------------+

Sortowanie - ORDER BY

Wiersze tabeli mogą być prezentowane nie tylko w określonej kolejności kolumn, ale również w określonej kolejności wierszy, na przykład sortowane po określonej kolumnie (klauzula ORDER BY):

mysql> SELECT * FROM jakczesto ORDER BY nazwa;
+----+------------+
| id | nazwa      |
+----+------------+
|  2 | co dzien   |
|  1 | co godzine |
|  4 | co miesiac |
|  3 | co tydzien |
+----+------------+

Sortowanie po polu tekstowym polega na ustawieniu wierszy w kolejności alfabetycznej.

mysql> SELECT * FROM jakczesto ORDER BY id DESC;
+----+------------+
| id | nazwa      |
+----+------------+
|  4 | co miesiac |
|  3 | co tydzien |
|  2 | co dzien   |
|  1 | co godzine |
+----+------------+

Dodając atrybut DESC do ORDER BY informujemy, że sortowanie ma być w odwrotnej kolejności.

Poniżej jest jest definicja i wypełnienie drugiej tabeli słownikowej potrzebnej w systemie:

mysql> CREATE TABLE typ (
    -> id INT NOT NULL AUTO_INCREMENT,
    -> nazwa VARCHAR(11),
    -> PRIMARY KEY (id) );
 
mysql> INSERT INTO typ (nazwa) VALUES ("pelny"), ("roznicowy"), ("przyrostowy");
mysql> SELECT * FROM typ;
+----+-------------+
| id | nazwa       |
+----+-------------+
|  1 | pelny       |
|  2 | roznicowy   |
|  3 | przyrostowy |
+----+-------------+

Tworzenie tabeli głównej

Tworzenie głównej tabeli dla aplikacji backupu powinno opierać się na zdefiniowanych założeniach. Dla przypomnienia: Jedną główną tabelę zawierającą ścieżki do folderów lub plików, które mają być backupowane oraz dla każdego wpisu informacje o tym jak często ma być backup wykonywany, jakiego typu to ma być backup i kiedy ostatnio był wykonywany.

mysql> CREATE TABLE backup (
    -> sciezka VARCHAR(255), #sciezka do pliku lub katalogu do backupu
    -> id_typ INT, #jakiego rodzaju to ma byc backup
    -> id_jakczesto INT, #jak czesto ma byc wykonywany backup
    -> data_ostatnio DATETIME ); #kiedy zostal ostatnio wykonany backup

Powyższa definicja tabeli zawiera nieomawiany wcześniej typ - DATETIME, który zawiera dzień i godzinę wykonania w formacie YYYY-MM-DD HH:MM:SS. Proszę zwrócić uwagę, że każdy wiersz tabeli nie będzie zawierał nazwy typu wykonywanego backupu (pełny, różnicowy, przyrostowy) tylko identyfikator dla tego typu (tabela typ ma już przypisanie 1-pełny, 2-różnicowy, 3-przyrostowy). Podobnie będzie z kolumną częstotliwości wykonywanych backupów (tabela jakczesto ma przypisanie 1-co godzinę, 2-dziennie, 3-tygodniowo, 4-miesięcznie).

Załóżmy, że administrator zbudował następujące założenia do wykonania backupu:

  • Katalog /etc
    • pełny backup co miesiąc
    • różnicowy backup co tydzień
    • przyrostowy backup co dzień
  • Katalog /var
    • pełny backup co tydzień
    • różnicowy backup co dzień
  • Plik /etc/shadow
    • pełny backup co miesiąc
    • różnicowy backup co godzinę

Wobec powyższych wypełnia tablicę backup:

mysql> INSERT INTO backup VALUES ("/etc/", 1, 4, NULL);
mysql> INSERT INTO backup VALUES ("/etc/", 2, 3, NULL);
mysql> INSERT INTO backup VALUES ("/etc/", 3, 2, NULL);
mysql> INSERT INTO backup VALUES ("/var/", 1, 3, NULL);
mysql> INSERT INTO backup VALUES ("/var/", 2, 2, NULL);
mysql> INSERT INTO backup VALUES ("/etc/shadow", 1, 4, NULL);
mysql> INSERT INTO backup VALUES ("/etc/shadow", 2, 1, NULL);

Czwarta kolumna każdego wpisu (data wykonania ostatniego backupu) ma wartość NULL - aplikacja do backupu w ten sposób może interpretować, że backup jeszcze nie był wykonywany.

Tabela po wyświetleniu wszystkich wpisów powinna wyglądać następująco:

mysql> select * from backup;
+-------------+--------+--------------+---------------+
| sciezka     | id_typ | id_jakczesto | data_ostatnio |
+-------------+--------+--------------+---------------+
| /etc/       |      1 |            4 | NULL          |
| /etc/       |      2 |            3 | NULL          |
| /etc/       |      3 |            2 | NULL          |
| /var/       |      1 |            3 | NULL          |
| /var/       |      2 |            2 | NULL          |
| /etc/shadow |      1 |            4 | NULL          |
| /etc/shadow |      2 |            1 | NULL          |
+-------------+--------+--------------+---------------+

Łączenie tabel - JOIN

Wyświetlanie tabeli w powyższej formie jest mało wygodne dla oglądającego, gdyż nie widać wprost jaki typ backupu będzie wykonywany i kiedy - trzeba się posiłkować dodatkowymi tabelami. Można przygotować zapytanie SQL, które połączy tabele ze sobą. Na początek połączmy dwie tabele - backup i typ aby było wiadomo jaki typ backupu będzie wykonywany.

Na początku wyświetlmy okrojoną tabelę backup do dwóch kolumn:

mysql> SELECT sciezka,id_typ FROM backup;
+-------------+--------+
| sciezka     | id_typ |
+-------------+--------+
| /etc/       |      1 |
| /etc/       |      2 |
| /etc/       |      3 |
| /var/       |      1 |
| /var/       |      2 |
| /etc/shadow |      1 |
| /etc/shadow |      2 |
+-------------+--------+

Poprzez połączenie (JOIN) tabeli backup z tabelą typ po identyfikatorze typu można uzyskać następujący wynik:

mysql> SELECT backup.sciezka, typ.nazwa 
    -> FROM backup
    -> JOIN typ ON backup.id_typ=typ.id;
+-------------+-------------+
| sciezka     | nazwa       |
+-------------+-------------+
| /etc/       | pelny       |
| /etc/       | roznicowy   |
| /etc/       | przyrostowy |
| /var/       | pelny       |
| /var/       | roznicowy   |
| /etc/shadow | pelny       |
| /etc/shadow | roznicowy   |
+-------------+-------------+

Możliwe jest również łączenie tabeli backup z obiema tabelami słownikowymi jednocześnie:

mysql> SELECT backup.sciezka, typ.nazwa, jakczesto.nazwa 
    -> FROM backup 
    -> JOIN typ ON backup.id_typ=typ.id 
    -> JOIN jakczesto ON backup.id_jakczesto=jakczesto.id; 
+-------------+-------------+------------+
| sciezka     | nazwa       | nazwa      |
+-------------+-------------+------------+
| /etc/       | pelny       | co miesiac |
| /etc/       | roznicowy   | co tydzien |
| /etc/       | przyrostowy | co dzien   |
| /var/       | pelny       | co tydzien |
| /var/       | roznicowy   | co dzien   |
| /etc/shadow | pelny       | co miesiac |
| /etc/shadow | roznicowy   | co godzine |
+-------------+-------------+------------+

Za pomocą instrukcji AS można zmienić domyślnie wyświetlające się nazwy kolumn:

mysql> SELECT backup.sciezka, typ.nazwa AS "typ backupu", jakczesto.nazwa AS "kiedy"
    -> FROM backup 
    -> JOIN typ ON backup.id_typ=typ.id 
    -> JOIN jakczesto ON backup.id_jakczesto=jakczesto.id; 
+-------------+-------------+------------+
| sciezka     | typ backupu | kiedy      |
+-------------+-------------+------------+
| /etc/       | pelny       | co miesiac |
| /etc/       | roznicowy   | co tydzien |
| /etc/       | przyrostowy | co dzien   |
| /var/       | pelny       | co tydzien |
| /var/       | roznicowy   | co dzien   |
| /etc/shadow | pelny       | co miesiac |
| /etc/shadow | roznicowy   | co godzine |
+-------------+-------------+------------+

Filtrowanie - WHERE

Klauzla WHERE była wykorzystywana wcześniej w przykładach kasowania wierszy lub zmiany wartości wierszy. Za jej pomocą można dokonywać operacji na wybranych, wyfiltrowanych wierszach. Jest ona również często stosowana przy wyświetlaniu zawartości tabel. Załóżmy, że chcemy wyświetlić tylko te wpisy tabeli backup, które dotyczą pełnego backupu:

mysql> SELECT backup.sciezka, typ.nazwa AS "typ backupu", jakczesto.nazwa AS "kiedy"
    -> FROM backup 
    -> JOIN typ ON backup.id_typ=typ.id 
    -> JOIN jakczesto ON backup.id_jakczesto=jakczesto.id
    -> WHERE typ.nazwa="pelny";
+-------------+-------------+------------+
| sciezka     | typ backupu | kiedy      |
+-------------+-------------+------------+
| /etc/       | pelny       | co miesiac |
| /var/       | pelny       | co tydzien |
| /etc/shadow | pelny       | co miesiac |
+-------------+-------------+------------+

lub tylko te, które są wykonywane każdego dnia:

mysql> SELECT backup.sciezka, typ.nazwa AS "typ backupu", jakczesto.nazwa AS "kiedy"
    -> FROM backup 
    -> JOIN typ ON backup.id_typ=typ.id 
    -> JOIN jakczesto ON backup.id_jakczesto=jakczesto.id
    -> WHERE jakczesto.nazwa="co dzien";
+---------+-------------+----------+
| sciezka | typ backupu | kiedy    |
+---------+-------------+----------+
| /etc/   | przyrostowy | co dzien |
| /var/   | roznicowy   | co dzien |
+---------+-------------+----------+

Filtry można ze sobą łączyć logicznymi operatorami AND lub OR:

mysql> SELECT backup.sciezka, typ.nazwa AS "typ backupu", jakczesto.nazwa AS "kiedy"
    -> FROM backup 
    -> JOIN typ ON backup.id_typ=typ.id 
    -> JOIN jakczesto ON backup.id_jakczesto=jakczesto.id
    -> WHERE typ.nazwa="pelny" AND jakczesto.nazwa="co miesiac";
+-------------+-------------+------------+
| sciezka     | typ backupu | kiedy      |
+-------------+-------------+------------+
| /etc/       | pelny       | co miesiac |
| /etc/shadow | pelny       | co miesiac |
+-------------+-------------+------------+

GROUP BY i funkcje agregujące

Klauzla GROUP BY potrafi być przydatna w przypadku konieczności zliczania pewnych wartości dla pewnych grup wierszy. Załóżmy, że chcemy zliczyć, ile jest w tabeli wpisów dotyczących pełnego backupu. Zacznijmy od wyświetlenia tabeli backup z jedną kolumną - typ backupu.

mysql> SELECT typ.nazwa AS "typ backupu"
    -> FROM backup 
    -> JOIN typ ON backup.id_typ=typ.id;
+-------------+
| typ backupu |
+-------------+
| pelny       |
| roznicowy   |
| przyrostowy |
| pelny       |
| roznicowy   |
| pelny       |
| roznicowy   |
+-------------+

Tabela nie wyświetla wszystkich kolumn, ale zawiera wszystkie wiersze. Jeśli chcemy pogrupować wiersze o identycznej wartości dodajemy na końcu klauzulę GROUP BY i nazwę kolumny, która ma być „grupowana”:

mysql> SELECT typ.nazwa AS "typ backupu"
    -> FROM backup 
    -> JOIN typ ON backup.id_typ=typ.id
    -> GROUP BY typ.nazwa;
+-------------+
| typ backupu |
+-------------+
| pelny       |
| przyrostowy |
| roznicowy   |
+-------------+

Funkcje agregujące pozwalają na wykonanie operacji na zgrupowanych przez GROUP BY wierszach. Na przykład na zliczanie liczby zgrupowanych wierszy - funkcja COUNT():

mysql> SELECT typ.nazwa AS "typ backupu", COUNT(*) AS "liczba"
    -> FROM backup 
    -> JOIN typ ON backup.id_typ=typ.id
    -> GROUP BY typ.nazwa;
+-------------+--------+
| typ backupu | liczba |
+-------------+--------+
| pelny       |      3 |
| przyrostowy |      1 |
| roznicowy   |      3 |
+-------------+--------+

Powyższe informuje nas, że w tabeli backup są trzy wpisy dotyczące backupu pełnego, jeden przyrostowy i trzy różnicowe.

A ile jest do wykonania backupów raz w tygodniu?

mysql> SELECT jakczesto.nazwa AS "kiedy", COUNT(*) AS "liczba"
    -> FROM backup 
    -> JOIN jakczesto ON backup.id_jakczesto=jakczesto.id
    -> WHERE jakczesto.nazwa="co tydzien"
    -> GROUP BY jakczesto.nazwa;
+------------+--------+
| kiedy      | liczba |
+------------+--------+
| co tydzien |      2 |
+------------+--------+

Istnieją też inne funkcje agregujące, które można wykorzystać z klauzulą GROUP BY, jak na przykład obliczanie wartości średniej arytmetycznej konkretnej kolumny dla zgrupowanych wierszy, jednakże nie da się ich zademonstrować na powyższej bazie danych - nie zawiera ona danych liczbowych.

Zadania

Zadania dla powyższego materiału znajdują się na osobnej stronie


Masz potrzebę, aby powyższa strona była rozbudowana? - Napisz do nas!.

materialy/podstawy-administracji/sql.txt · ostatnio zmienione: 2015/03/01 21:45 przez mzalewski

(C) 2017 ITMZ Mariusz Zalewski