Kurs MySQL
Pliki do ćwiczeń dane.txt oraz sql.sql (patrz ANEKS 1 i 2 na końcu kursu)
1. Wpisujemy pierwszą komendę - czyli tworzymy bazę danych 'szkolnaDB':
mysql> create database szkolnaDB;
Wynikiem będzie:
Query OK, 1 row affected (0.00 sec)
W ten sposób utworzyliśmy bazę danych w której będziemy mogli tworzyć tabele.
By wyświetlić bazy istniejące na naszym serwerze wpisujemy polecenie select database();
mysql> select database();
+------------+
| database() |
+------------+
| NULL |
+------------+
1 row in set (0.00 sec)
2. Tworzenie tabeli w MySQL (CREATE TABLE MySQL).
Tabele w MySQL tworzymy przy użyciu polecenia CREATE TABLE nazwa (kolumny typ danych constraint). Pamiętać należy, że kolumny w obrębie tabeli muszą mieć unikalne nazwy, nie mogą posiadać w nazwie liter polskich oraz muszą mieć zdefiniowany typ danych.
Przed wykonaniem kodu należy przełączyć się na bazę szkoleniową poleceniem
Przykład tworzenie tabeli MySql:
create table dane
(
imie varchar(15) not null,
nazwisko varchar(20) not null,
email varchar(50) null,
ulica varchar(50) null,
miasto varchar(50) null,
data_ur date null,
aktywny int default 1
) ;
Atrybuty kolumn w tabeli MySQL:
NOT NULL - powoduje, że wartość w danym polu nie może być null
AUTO_INCREMENT - auto numerowanie w kolumnie, każdy rekord automatycznie podczas insertu otrzymuje kolejny numer.
Uwaga: ten atrybut może być użyty tylko z zawężeniem PRIMARY KEY
PRIMARY KEY - powoduje, że dane w kolumnie nie mogą się powtarzać, służy do identyfikacji rekordu.
FOREIGN KEY - odwołanie do klucza głównego z innej tabeli.
UNIQUE - powoduje, że dane w kolumnie nie mogą się powtarzać.
DEFAULT - domyślna wartość dla pola, w przypadku nie podania wartości dla kolumny w rekordzie zostanie zainsertowana wartość default
UNSIGNED - powoduje, że kolumna nie może przechowywać wartości na minusie przy czym zakres pozostaje taki sam, działa tylko dla typów przechowujących liczby całkowite
ZEROFILL - czyli zerowe wypełnienie, w przypadku gdy ilość liczb w polu będzie mniejsza niż ta zadeklarowana przy tworzeniu kolumny wartość pola będzie automatycznie "dopełniana" zerami na początku, działa tylko dla typów przechowujących liczby całkowite, automatycznie tworzy atrybut UNSIGNED
By obejrzeć wynik działania polecenia CREATE TABLE wpisujemy polecenie DESCRIBE:
CREATE TABLE nazwa_tabeli (musi być zapisana ciągiem bez spacji ewentualnie w apostrofach można stosować przerwy w nazwach tabel)
(id(nazwa kolumny) TINYINT(typ danych) AUTO_INCREMENT (autonumerowanie)
PRIMARY KEY(id) (klucz tabeli)
)TYPE=MyISAM; (typ silnika bazy danych jaki chcemy wykorzystać, opcjonalne)
+----------+-------------+------+-----+---------+-------+
| Field | Type |Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| imie | varchar(15) | NO | | NULL | |
| nazwisko | varchar(20) | NO | | NULL | |
| email | varchar(50) | YES | | NULL | |
| ulica | varchar(50) | YES | | NULL | |
| miasto | varchar(50) | YES | | NULL | |
| data_ur | date | YES | | NULL | |
| aktywny | int(11) | YES | | 1 | |
+----------+-------------+------+-----+---------+-------+
7 rows in set (0.00 sec)
Polecenia możemy również wywoływać z pliku, tworzymy plik sql.sql z kodem:
describe dane;
Następnie uruchamiamy go poleceniem:
mysql> \. sql.sql
Wynik będzie taki sam jak powyżej.
Aby dodać nowy rekord do tabeli należy użyć polecenia:
mysql> insert into dane (imie,nazwisko,email,ulica,miasto,data_ur)
-> values('Mariusz','Kowalski','mk@op.pl','Polna','Warszawa','1980-02-25');
Query OK, 1 row affected (0.00 sec)
W wyniku polecenia pojawi się nowy rekord w tabeli dane. Oczywiście są inne sposoby dodania rekordu czyli inna składnia INSERT INTO.
Ładowanie danych z pliku w MySQL.
Można również załadować dane z pliku używając polecenia
Kolumny dla tego polecenia powinny być oddzielone tabulatorami a wiersze znakami końca wiersza.
Inny sposób to program do ładowania danych w MySQL.
mysqlimport --local dane dane.txt
4. Pobieranie danych z bazy MySQL - instrukcja SELECT
SELECT
[ALL | DISTINCT | DISTINCTROW ]
select_expr [, select_expr ...]
[FROM table_nazwa
[WHERE filtry]
[GROUP BY {nazwa_kolumny | expr | position}
[ASC | DESC], ... [WITH ROLLUP]]
[HAVING filtry_agregaty]
[ORDER BY {nazwa_kolumny | expr | position}
[ASC | DESC], ...]
[LIMIT {[offset,] ilosc_wierszy | ilosc_wierszy OFFSET offset}]
Przykład użycia polecenia SELECT w MySQL:
mysql> select * from dane;
+--------+----------+---------+----------+----------+------------+-------+
| imie | nazwisko | email | ulica | miasto | data_ur |aktywny|
+--------+----------+---------+----------+----------+------------+-------+
| Mariusz| Kowalski | mk@op.pl| Polna | Warszawa | 1980-02-25 | 1 |
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00 | 0 |
| Marek | Edza | e@o.pl | Sienna | Warszawa | 0000-00-00 | 0 |
| Ewa | Knaz | e@op.pl | Marszalka| Warszawa | 0000-00-00 | 0 |
+--------+----------+---------+----------+----------+------------+-------+
4 rows in set (0.00 sec)
Jeśli chcemy wybrać konkretne kolumny po poleceniu SELECT w MySQL wpisujemy nazwę kolumn lub jednej wybranej kolumny.
+----------+
| email |
+----------+
| mk@op.pl |
| k@op.pl |
| e@o.pl |
| e@op.pl |
+----------+
4 rows in set (0.00 sec)
mysql> select ulica,miasto from dane;
+-----------+----------+
| ulica | miasto |
+-----------+----------+
| Polna | Warszawa |
| Polna | Warszawa |
| Sienna | Warszawa |
| Marszalka | Warszawa |
+-----------+----------+
4 rows in set (0.00 sec)
mysql> select * from dane where ulica='Polna';
+---------+----------+----------+-------+----------+-----------+---------+
| imie | nazwisko | email | ulica | miasto | data_ur | aktywny |
+---------+----------+----------+-------+----------+-----------+---------+
| Mariusz | Kowalski | mk@op.pl | Polna | Warszawa | 1980-02-25| 1 |
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00| 0 |
+---------+----------+----------+-------+----------+-----------+---------+
2 rows in set (0.00 sec)
Można użyć oczywiście większej ilości filtrów należy wtedy łączyć warunki używając AND.
mysql> select * from dane where ulica='Polna' and aktywny = 0;
+--------+----------+---------+-------+----------+------------+---------+
| imie | nazwisko | email | ulica | miasto | data_ur | aktywny |
+--------+----------+---------+-------+----------+------------+---------+
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00 | 0 |
+--------+----------+---------+-------+----------+------------+---------+
1 row in set (0.00 sec)
Przy filtrowaniu danych możemy stosować operatory arytmetyczne, porównania i logiczne.
Operatory arytmetyczne:
+ dodawanie
- odejmowanie
* mnożenie
/ dzielenie
Operatory porównania:
< mniejsze niż
<= mniejsze niż lub równe
= równe
!= lub <> nierówne
>= większe niż lub równe
> większe niż
Operatory logiczne:
AND logiczne „i”
OR logiczne „lub”
NOT logiczne przeczenie "nie"
Możemy korzystać również z polecenia IN pozwala ono na zdefiniowanie wartości jakie nas interesują dla kolumny.
+---------+----------+----------+--------+----------+------------+-------+
| imie | nazwisko | email | ulica | miasto | data_ur |aktywny|
+---------+----------+----------+--------+----------+------------+-------+
| Mariusz | Kowalski | mk@op.pl | Polna | Warszawa | 1980-02-25 | 1 |
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00 | 0 |
| Marek | Edza | e@o.pl | Sienna | Warszawa | 0000-00-00 | 0 |
+---------+----------+----------+--------+----------+------------+-------+
3 rows in set (0.00 sec)
Możliwe jest też filtrowanie po fragmencie tekstu w kolumnie/kolumnach służy do tego polecenie LIKE w MySQL poprzez znak % (polecenia) oznaczamy dowolny tekst, a znak „_” (podkreślnik) oznacza jeden dowolny znak.
mysql> select * from dane where ulica like 'P%';
+---------+----------+----------+-------+----------+------------+--------+
| imie | nazwisko | email | ulica | miasto | data_ur | aktywny|
+---------+----------+----------+-------+----------+------------+--------+
| Mariusz | Kowalski | mk@op.pl | Polna | Warszawa | 1980-02-25 | 1 |
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00 | 0 |
+---------+----------+----------+-------+----------+------------+--------+
2 rows in set (0.00 sec)
Przykład użycia polecenia OR w MySQL
mysql> select * from dane where ulica like 'P%' or aktywny =0;
+--------+---------+---------+----------+----------+-----------+---------+
| imie | nazwisko| email | ulica | miasto | data_ur | aktywny |
+--------+---------+---------+----------+----------+-----------+---------+
| Mariusz| Kowalski| mk@op.pl| Polna | Warszawa | 1980-02-25| 1 |
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00| 0 |
| Marek | Edza | e@o.pl | Sienna | Warszawa | 0000-00-00| 0 |
| Ewa | Knaz | e@op.pl | Marszalka| Warszawa | 0000-00-00| 0 |
+--------+---------+---------+----------+----------+-----------+---------+
4 rows in set (0.00 sec)
Tu trzeba zaznaczyć że przy kilku warunkach z OR i AND trzeba je łączyć w nawiasach.
Czasami niezbędne jest usunięcie duplikatów z zapytania, używamy do tego polecenia DISITINCT w MySQL (czyli odfiltrowanie powtarzających się duplikatów).
mysql> select distinct ulica from dane;
+-----------+
| ulica |
+-----------+
| Polna |
| Sienna |
| Marszalka |
+-----------+
3 rows in set (0.00 sec)
Celem ograniczenia ilości wierszy w MySQL używamy polecenia LIMIT ilość_rekordów (działa jak TOP w t-sql).
mysql> select * from dane limit 1;
+---------+----------+----------+-------+----------+------------+--------+
| imie | nazwisko | email | ulica | miasto | data_ur | aktywny|
+---------+----------+----------+-------+----------+------------+--------+
| Mariusz | Kowalski | mk@op.pl | Polna | Warszawa | 1980-02-25 | 1 |
+---------+----------+----------+-------+----------+------------+--------+
1 row in set (0.00 sec)
Ważne jest również fakt, że w filtrach WHERE jak i w SELECT możemy używać funkcji matematycznych służących do obliczeń w MySQL.
mysql> select 2*2 as wynik ;
+-------+
| wynik |
+-------+
| 4 |
+-------+
1 row in set (0.00 sec)
mysql> select * from dane where aktywny+2=2;
+--------+---------+---------+-----------+----------+------------+-------+
| imie | nazwisko| email | ulica | miasto | data_ur |aktywny|
+--------+---------+---------+-----------+----------+------------+-------+
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00 | 0 |
| Marek | Edza | e@o.pl | Sienna | Warszawa | 0000-00-00 | 0 |
| Ewa | Knaz | e@op.pl | Marszalka | Warszawa | 0000-00-00 | 0 |
+--------+---------+---------+-----------+----------+------------+-------+
3 rows in set (0.00 sec)
Sortownie wyniku zapytania w mysql odbywa się poprzez użycie klauzuli ORDER BY.
Klauzule ORDER BY stosujemy, jako ostatni element kwerendy w mysql.
Przykład sortowanie mysql:
+--------+---------+----------+-----------+----------+-----------+-------+
| imie | nazwisko| email | ulica | miasto | data_ur |aktywny|
+--------+---------+----------+-----------+----------+-----------+-------+
| Ewa | Knaz | e@op.pl | Marszalka | Warszawa | 0000-00-00| 0 |
| Marek | Edza | e@o.pl | Sienna | Warszawa | 0000-00-00| 0 |
| Mariusz| Kowalski| mk@op.pl | Polna | Warszawa | 1980-02-25| 1 |
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00| 0 |
+--------+---------+----------+-----------+----------+-----------+-------+
4 rows in set (0.00 sec)
Sortować możemy rosnąco ASC (domyślnie) lub malejąco DESC.
-> ;
+--------+---------+---------+-----------+----------+------------+-------+
| imie | nazwisko| email | ulica | miasto | data_ur |aktywny |
+--------+---------+---------+-----------+----------+------------+-------+
| Stefan | Kawa | k@op.pl | Polna | Warszawa | 0000-00-00 | 0 |
| Mariusz| Kowalski| mk@op.pl| Polna | Warszawa | 1980-02-25 | 1 |
| Marek | Edza | e@o.pl | Sienna | Warszawa | 0000-00-00 | 0 |
| Ewa | Knaz | e@op.pl | Marszalka | Warszawa | 0000-00-00 | 0 |
+--------+---------+---------+-----------+----------+------------+-------+
4 rows in set (0.00 sec)
Sortować możemy po kolumnie, kolumnach lub wyrażeniu np. używając funkcji lub działania. Dopuszczalne jest również podanie nr kolumny po której chcemy sortować.
Przykład:
mysql> select * from dane order by 1, aktywny+1,concat(imie,nazwisko);
+--------+---------+----------+-----------+---------+------------+-------+
| imie | nazwisko| email | ulica | miasto | data_ur |aktywny|
+--------+---------+----------+-----------+---------+------------+-------+
| Ewa | Knaz | e@op.pl | Marszalka | Warszawa| 0000-00-00 | 0 |
| Marek | Edza | e@o.pl | Sienna | Warszawa| 0000-00-00 | 0 |
| Mariusz| Kowalski| mk@op.pl | Polna | Warszawa| 1980-02-25 | 1 |
| Stefan | Kawa | k@op.pl | Polna | Warszawa| 0000-00-00 | 0 |
+--------+---------+----------+-----------+---------+------------+-------+
4 rows in set (0.00 sec)
Łączenie kolumn w Mysql odbywa się po przez użycie funkcji CONCAT.
mysql> select concat(imie,' ',nazwisko) from dane;
+---------------------------+
| concat(imie,' ',nazwisko) |
+---------------------------+
| Mariusz Kowalski |
| Stefan Kawa |
| Marek Edza |
| Ewa Knaz |
+---------------------------+
4 rows in set (0.00 sec)
MySql posiada kilka funkcji do agregowania danych i prowadzenia statystyk, są to:
Count(*) – oblicz ilość rekordów w wyniku
AVG – średnia
MIN – wartość minimalna w kolumnie
MAX – wartość maksymalna
SUM – suma wierszy w kolumnie
Przykład użycia:
mysql> select count(*) from dane;
+----------+
| count(*) |
+----------+
| 4 |
+----------+
1 row in set (0.00 sec)
9. Gdy chcemy wskazać kolumny dla których chcemy obliczyć wartości należy użyć klauzuli GROUP BY - czyli tzw. grupowania wyników.
mysql> select count(*),ulica from dane group by ulica;
+----------+-----------+
| count(*) | ulica |
+----------+-----------+
| 1 | Marszalka |
| 2 | Polna |
| 1 | Sienna |
+----------+-----------+
3 rows in set (0.00 sec)
Gdy chcemy obliczać statystyki dla kolumn poza funkcją należy używać klauzuli GROUP BY w innym przypadku program zgłosi błąd.
Możliwe jest również obliczenie statystyk dla niepowtarzających się rekordów używając DISTINCT:
mysql> select count(*),count(ulica),count(distinct ulica),ulica from dane group by ulica;
+----------+--------------+-----------------------+-----------+
| count(*) | count(ulica) | count(distinct ulica) | ulica |
+----------+--------------+-----------------------+-----------+
| 1 | 1 | 1 | Marszalka |
| 2 | 2 | 1 | Polna |
| 1 | 1 | 1 | Sienna |
+----------+--------------+-----------------------+-----------+
3 rows in set (0.00 sec)
ANEKSY
______________________________________________________________
ANEKS 1 plik txt (skopiuj poniższe dane do notatnika i zapisz jako dane.txt)
Stefan Kawa k@op.pl Polna Warszawa 1
Marek Edza e@o.pl Sienna Warszawa 1
Ewa Knaz e@op.pl Marszalka Warszawa 1
______________________________________________________________
ANEKS 2 plik SQL (skopiuj poniższe dane do notatnika i zapisz jako sql.sql)
use szkolnaDB
describe dane;
______________________________________________________________
Pobierz w pdf
PRZEGLĄD PODSTAWOWEJ SKŁADNI JĘZYKA MySQL
Główna forma zapytania SELECT
DISTINCT oznacza nie powtarzające się wiersze.
SELECT [DISTINCT] nazwy(a)_kolumny /*
FROM nazwa_tabeli;
Selekcja wierszy z tabeli z warunkiem
SELECT [DISTINCT] nazwy(a)_kolumny
FROM nazwa_tabeli
WHERE nazwa_kolumny operator_porównania wartość;
Uporządkowanie wierszy
SELECT [DISTINCT] nazwy(a)_kolumny /*
FROM nazwa_tabeli
ORDER BY nazwy(a)_kolumn(y) / numer(y)_kolumn(y) [ASC/DESC-rosnąco/malejąco];
Operatory porównania
= równe
< mniejsze niż
!= nie równe
<= mniejsze niż lub równe
> większe niż
>= większe niż lub równe
Warunek iloczynowy (AND)
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE warunek AND warunek ;
Alternatywny warunek zapytania
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE warunek OR warunek ;
Wyszukiwania zakresowe (BETWEEN)
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE nazwa_kolumny
[NOT] BETWEEN wartość_1 AND wartość_2 ;
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE wartość
[NOT] BETWEEN nazwa_kolumny_1 AND nazwa_kolumny_2
Poszukiwanie wzorców znakowych (LIKE)
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE nazwa_kolumny
[NOT] LIKE "napis" ;
Wyszukiwanie wartości NULL
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE nazwa_kolumny IS [NOT] NULL ;
Operatory porównania zbioru (IN)
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE nazwa_kolumny
[NOT] IN (wartość_1, wartość_2, .....) ;
Funkcje wbudowane
SELECT funkcja_wbudowana [DISTINCT] nazwa_kolumny
FROM nazwa_tabeli
[WHERE warunek] ;
Funkcje wbudowane w SQL
AVG
SUM
MIN
MAX
COUNT (może być użyta razem z *
Obliczenia
SELECT nazwy(a)_kolumn(y), wyrażenie arytmetyczne
FROM nazwa_tabeli
[WHERE warunek]
[ORDER BY nazwy(a)_kolumn(y) / *] ;
Operatory arytmetyczne
+ dodawanie
- odejmowanie
* mnożenie
/ dzielenie
Podzapytania
Zapytanie główne:
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE nazwa_kolumny
operator_porównania / operator_porównania zbioru
pod zapytanie:
(SELECT nazwa_kolumny
FROM nazwa_tabeli
[WHERE warunek] );
Grupowanie
SELECT nazwy(a)_kolumn(y), funkcja_wbudowana(argument)
FROM nazwa_tabeli
[WHERE warunek]
GROUP BY nazwy(a)_kolumn(y)
[HAVING warunek]
[ORDER BY nazwy(a)_kolumny / numer(y)_kolumn(y) [ASC/DESC]] ;
Złączanie tabel
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli, nazwa_tabeli [,nazwa_tabeli, .....]
WHERE warunek_złączenia
[AND / OR warunek]
[ORDER BY nazwy(a)_kolumny / numer(y)_kolumn(y)] ;
Operowanie danymi
Wstawianie wierszy do tabeli
INSERT INTO nazwa_tabeli
[(nazwa_kolumny_1, nazwa_kolumny_2, ....)]
VALUES (wartość_1, wartość_2, ...);
INSERT INTO nazwa_tabeli
[(nazwa_kolumny_1, nazwa_kolumny_2, ....)]
VALUES (wartość_1, wartość_2, ...)
SELECT nazwy(a)_kolumn(y)
FROM nazwa_tabeli
WHERE warunek;
Aktualizacja danych
UPDATE nazwa_tabeli / nazwa_perspektywy
SET nazwa_kolumny_1=wartość / wyrażenie_arytmetyczne,
..........
nazwa_kolumny_n=wartość / wyrażenie_arytmetyczne
[WHERE warunek];
Kasowanie wierszy z tabeli
DELETE FROM nazwa_tabeli
[WHERE warunek];
Definiowanie danych, tworzenie tablic
CREATE TABLE nazwa_tabeli
(nazwa_kolumny_1 typ_danych [NOT NULL]
nazwa_kolumny_2 typ_danych [NOT NULL]
...........
nazwa_kolumny_n typ_danych [NOT NULL];
CREATE TABLE Klienci
(ID_Klienta Number(4) PRIMARY KEY,
Imie Varchar2(20) NOT NULL,
Nazwisko Varchar2(20) NOT NULL,
Status Varchar2(10) DEFAULT 'Aktualny');
Definiowanie danych, zmiana tablic
ALTER TABLE nazwa_tabeli
ADD nazwa_kloumny typ_danych;
ALTER TABLE Klienci
ADD (Telefon Varchar2(10));
DROP TABLE nazwa_tabeli;
Definiowanie danych, tworzenie indeksu
CREATE [UNIQUE] INDEX nazwa_indeksu
ON nazwa_tabeli (nazwy(a)_kolumny [ASC/DESC]);
Definiowanie danych, usuwanie indeksu
DROP INDEX (nazwa_indeksu);
Definiowanie danych, tworzenie synonimu
CREATE SYNONYM nazwa_synonimu
FOR nazwa_tabeli / nazwa_perspektywy;
Definiowanie danych, usuwanie synonimu
DROP SYNONYM nazwa_synonimu;
Definiowanie danych, tworzenie perspektywy
CREATE VIEW nazwa_perspektywy
AS instrukcja_zapytania_w_SQL ;
Definiowanie danych, usuwanie perspektywy
DROP VIEW nazwa_perspektywy;
Administrowanie danymi
Przyznanie uprawnienia:
GRANT ALL / SELECT / UPDATE / INSERT / DELETE / INDEX / ALTER
dla obiektu:
ON nazwy(a)_tabel(i) / nazwa_perspektyw(y)
dla użytkownika:
TO nazwy(a)_użytkowników(a);
Usunięcie uprawnień
REVOKE ALL / SELECT / UPDATE / INSERT / DELETE / INDEX / ALTER
ON nazwy(a)_tabel(i) / nazwa_perspektyw(y)
TO nazwy(a)_użytkowników(a);
_______________________________________________________________________________