Wprowadzenie do systemu zarządzania bazą danych MySQL

1.  Rozpoczynamy pracę z MySQL

Wprowadzenie

MySQL jest jednym z najpopularniejszych serwerów baz danych. Do komunikacji z innymi programami używa standardowego języku zapytań (SQL) wraz z własnymi rozszerzonymi jego funkcjami. W tym tekście omówiona zostanie wstępna instalacja serwera MySQL, tworzenie baz danych i tabel oraz dodawanie nowych użytkowników bazy. Zacznijmy od wstępnej instalacji.

Instalacja MySQL

Po pierwsze należy się upewnić, że w systemie jest już zainstalowany serwer MySQL. Jeżeli nie, należy wykonać prostą komendę:

(Sprawdzamy dostępne flagi USE)
# emerge --pretend --verbose mysql
(Instalujemy MySQL)
# emerge mysql

Po zakończonej instalacji zostanie wyświetlona następująca uwaga:

You might want to run:
"emerge --config =dev-db/mysql-[version]"
if this is a new install.

Zgodnie z zaleceniami należy wykonać powyższe polecenie, oczywiście tylko wówczas, jeżeli przeprowadzamy instalację pierwszy raz.

([version] zastępujemy numerem wersji, którą właśnie
zainstalowaliśmy).
# emerge --config =dev-db/mysql-[version]
 * MySQL DATADIR is /var/lib/mysql
 * Press ENTER to create the mysql database and set proper
 * permissions on it, or Control-C to abort now...

   Preparing db table
   Preparing host table
   Preparing user table
   Preparing func table
   Preparing tables_priv table
   Preparing columns_priv table
   Installing all prepared tables

   To start mysqld at boot time you have to copy support-files/mysql.server
   to the right place for your system

   PLEASE REMEMBER TO SET A PASSWORD FOR THE MySQL root USER !
   To do so, issue the following commands to start the server
   and change the applicable passwords:
   /etc/init.d/mysql start
   /usr/bin/mysqladmin -u root -h pegasos password 'new-password'
   /usr/bin/mysqladmin -u root password 'new-password'
   Depending on your configuration, a -p option may be needed
   in the last command. See the manual for more details.

Usunąłem tutaj część zbędnych komunikatów, aby ten dokument pozostał tak zwięzły jak to tylko możliwe.

   * For security reasons you should set your MySQL root
   * password as soon as possible.

Wciskając klawisz ENTER podczas konfiguracji bazy MySQL sprawiamy, że uruchomiony zostaje proces, w którym tworzona jest główna baza MySQL i wypełniana początkowymi danymi. Zawiera ona informacje o dostępnych bazach danych, tabelach, użytkownikach, prawach dostępu i wiele innych ciekawych informacji. Konfiguracja zaleca zmianę hasła użytkownika root tak szybko jak to tylko możliwe. Zrobimy to teraz ponieważ w przeciwnym wypadku, ktoś może zmienić naszą domyślną konfigurację serwera MySQL. Jesteśmy na etapie konfiguracji, która umożliwia nam łatwe ustawienie tego hasła, zatem zróbmy to teraz:

# /etc/init.d/mysql start
 * Re-caching dependency info (mtimes differ)...
 * Starting mysqld (/etc/mysql/my.cnf) ...
 * [ ok ]
$ /usr/bin/mysqladmin -u root -h localhost password 'nowe-hasło'

Możemy teraz sprawdzić czy hasło zostało poprawnie zapisane próbując zalogować się do serwera MySQL:

$ mysql -u root -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Argument -u to konto na którym chcemy pracować, argument -h to komputer na którym pracuje nasz serwer baz danych. Zwykle będzie to localhost, chyba że konfigurujemy serwer zdalnie. W końcu -p mówi, że będziemy chcieli uwierzytelnić się za pomocą hasła. Powinniśmy ujrzeć teraz zachętę mysql>. Jest to miejsce, gdzie będziemy wpisywali wszystkie komendy. Teraz kiedy już jesteśmy zalogowani jako użytkownik root, możemy rozpocząć konfigurację naszej bazy danych.

2.  Konfiguracja bazy danych

Tworzenie nowej bazy danych

Zacznijmy od obejrzenia wszystkich dostępnych baz danych jakie posiadamy. Aby tego dokonać wydajemy polecenie SHOW DATABASES jak poniżej:

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| mysql    |
| test     |
+----------+
2 rows in set (0.09 sec)

Pomimo tego że baza danych test jest już utworzona, utworzymy sobie własną dla bardziej kompletnego przewodnika. Tworzenie baz danych odbywa się za pomocą polecenia CREATE DATABASE. Utwórzmy zatem bazę danych i nazwijmy ją gentoo:

mysql> CREATE DATABASE gentoo;
Query OK, 1 row affected (0.08 sec)

Odpowiedź serwera pozwala nam stwierdzić, że polecenie zostało wykonane poprawnie. W tym przypadku jeden wiersz został zmodyfikowany. Jest to odniesienie do głównej bazy danych "mysql", która przechowuje listę wszystkich baz danych. Nie musimy się jednak martwić o szczegóły. Ostatnią liczbą jest czas w jakim zapytanie do bazy zostało wykonane. Możemy teraz sprawdzić, że faktycznie baza danych została utworzona wydając komendę SHOW DATABASES po raz kolejny:

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| gentoo   |
| mysql    |
| test     |
+----------+
3 rows in set (0.00 sec)

Rzeczywiście nasza baza danych została utworzona. Teraz będziemy chcieli utworzyć w naszej bazie tabelę, jednak zanim to uczynimy musimy wybrać bazę na której będziemy pracowali. Aby tego dokonać używamy komendy USE. Przyjmuje ona jako argument nazwę bazy danych na której chcemy pracować. Bazę danych możemy także wybrać już przy łączeniu się z serwerem podając jej nazwę po argumencie -D. Wybierzmy zatem teraz bazę którą utworzyliśmy przed chwilą:

mysql> USE gentoo;
Database changed

Aktualną bazą danych jest teraz ta, którą przed chwilą utworzyliśmy. Jeżeli już została wybrana jako aktywna, możemy przejść do utworzenia w niej przykładowej tabeli i wypełnienia jej informacjami.

3.  Praca z tabelami w MySQL

Tworzenie nowej tabeli

Strukturę MySQL tworzą: bazy danych, tabele, rekordy i pola. Bazy danych zawierają tabele, tabele zawierają rekordy, rekordy zawierają pola, w których to zapisane są informacje. Struktura ta pozwala użytkownikom uporządkowanie swoich informacji. Do tej pory zajmowaliśmy się bazami danych, teraz przyszła pora na pracę z tabelami. Po pierwsze, dostępne tabele możemy przeglądać podobnie jak bazy danych, używając komendy SHOW TABLES. W tej chwili nie ma żadnych tabel w naszej bazie gentoo:

mysql> SHOW TABLES;
Empty set (0.00 sec)

Stwórzmy więc przykładową tabelę. Aby tego dokonać, użyjemy komendy CREATE TABLE Jednak komenda ta jest całkiem inna od prostego CREATE DATABASE. Przyjmuje ona listę argumentów, którą musimy podać:

CREATE TABLE [nazwa_tabeli] ([nazwa_pola] [typ_pola]([rozmiar]));

nazwa_tabeli jest nazwą jaką chcemy nadać tworzonej tabeli. W tym przykładzie nazwijmy ją developers. Tabela ta będzie zawierała imię i nazwisko dewelopera, email i to czym się ma zajmować. Co z typami tych pól? Typ pola zawiera informacje o tym jakie dane będą w nim przechowywane. Wszystkie dostępne typy można znaleźć na tej stronie. Dla naszych celów użyjemy typu danych VARCHAR dla wszystkich pól. VARCHAR jest jednym z najprostszych typów danych, jeżeli chodzi o pracę z łańcuchami znakowymi. Rozmiar oznacza ile takich typów danych stworzymy. W tym przykładzie użyjemy pól o wielkości 128. Będzie to oznaczało, że możemy umieścić w tym polu 128 typów danych VARCHAR. Można spokojnie uważać to pole po prostu jako 128 znaków, chociaż istnieje bardziej techniczne wytłumaczenie, dostępne na podanej wcześniej stronie. Teraz, kiedy już wiemy jak tworzyć tabele, zróbmy to:

mysql> CREATE TABLE developers ( name VARCHAR(128), email VARCHAR(128), job VARCHAR(128));
Query OK, 0 rows affected (0.11 sec)

Wygląda na to, że wszystko przebiegło poprawnie. Sprawdźmy zatem wynik komendy SHOW TABLES:

mysql> SHOW TABLES;
+------------------+
| Tables_in_gentoo |
+------------------+
| developers       |
+------------------+
1 row in set (0.00 sec)

Tak, oto i nasza tabela. Jednak nie wygląda na to żeby pokazały się informacje o typach pól jakie ustaliliśmy. Aby je uzyskać użyjemy komendy DESCRIBE, która pobiera jako argument nazwę tabeli. Zobaczmy zatem co zwróci nam to polecenie w odniesieniu do tabeli developers:

mysql> DESCRIBE developers;
+-------+--------------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| name  | varchar(128) | YES  |     | NULL    |       |
| email | varchar(128) | YES  |     | NULL    |       |
| job   | varchar(128) | YES  |     | NULL    |       |
+-------+--------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

Pokazała się nam tabela z polami oraz ich typami. Widzimy także kilka dodatkowych atrybutów, które są jednak poza zasięgiem tego dokumentu. Ich opisy są dostępne w dokumentacji MySQL. Mamy w tej chwili tabelę z którą możemy pracować. Wprowadźmy zatem do niej przykładowe dane.

Umieszczanie informacji w bazie danych

Teraz kiedy już mamy własną tabelę, włóżmy do niej jakieś informacje. Służy do tego polecenie INSERT. Tak jak CREATE TABLE, ono także ma specyficzną formę:

INSERT INTO [nazwa_tabeli] VALUES('wartość1', 'wartość2', ...);

Komenda ta służy do dodawania rekordów do tabeli. nazwa_tabeli to po prostu tabela MySQL, do której zamierzamy wprowadzić informacje. VALUES() zawiera informacje, które chcemy umieścić w tabeli. W tym przypadku chcemy dodać informacje do tabeli developers. Zatem dodajmy przykładowy rekord z danymi 'Joe Smith', 'joesmith@gentoo.org', 'toolchain'. Postępujemy następująco:

mysql> INSERT INTO developers VALUES('Joe Smith', 'joesmith@gentoo.org', 'toolchain');
Query OK, 1 row affected (0.06 sec)

Wygląda na to, że rekord został dodany poprawnie. Co jeśli byśmy chcieli dodać więcej niż jeden rekord? Inną wygodną komendą jest LOAD DATA. Służy ona do ładowania oddzielonych tabulacjami informacji z pliku. Spróbujmy zatem stworzyć w naszym katalogu domowym plik z przykładowymi danymi. Nazwijmy go records.txt. Na przykład:

John Doe        johndoe@gentoo.org      portage
Chris White     chriswhite@gentoo.org   documentation
Sam Smith       samsmith@gentoo.org     amd64

Komenda LOAD DATA posiada nieco przydługawą definicję, jednak my użyjemy najprostszej jej formy:

LOAD DATA LOCAL INFILE '/ścieżka/do/pliku' INTO TABLE tabela;

/ścieżka/do/pliku jest po prostu katalogiem i plikiem, którego zamierzamy użyć. tabela jest nazwą tabeli. W naszym przypadku plikiem jest ~/records.txt, a tabelą developers:

mysql> LOAD DATA LOCAL INFILE '~/records.txt' INTO TABLE developers;
Query OK, 3 rows affected (0.00 sec)
Records: 3  Deleted: 0  Skipped: 0  Warnings: 0

Komenda ta jedynie umieszcza rekordy w tabeli i nie daje żadnej kontroli nad serwerem MySQL. Wiele aplikacji internetowych używa skryptów sql do szybkiej i prostej konfiguracji serwera MySQL. Jeżeli zechcemy użyć takiego skryptu, będziemy musieli uruchomić MySQL w trybie wsadowym lub użyć polecenia source. Oto przykład uruchamiania mysql w trybie wsadowym:

$ mysql -u root -h localhost -p < plik_sql

Tak jak przy poleceniu LOAD DATA, tak i tutaj należy być pewnym co taki skrypt zawiera. Użycie pliku nieznanego pochodzenia może spowodować naruszenie ochrony bazy danych! Inną metodą załadowania takiego skryptu jest użycie polecenia source. Uruchomi ono komendy zapisane w skrypcie z poziomu trybu interaktywnego mysql. A oto i przykład użycia komendy source:

mysql> source plik_sql;

Jeżeli napotkamy na aplikację internetową oczekującą na uruchomienie pliku sql, wtedy dwie powyższe komendy mogą zostać użyte. Mamy zatem wypełnioną naszą tabelę. Jak teraz sprawdzić co zawierają nasze pola? Dokonamy tego przez przeszukiwanie naszej tabeli za pomocą zapytań.

Przeglądanie tabel MySQL za pomocą zapytań

Zapytania są jedną z głównych możliwości jakie oferuje każda baza danych SQL. To one pomagają nam interpretować informacje pochodzące z naszych tabel jako coś przydatnego. Większość zapytań realizowana jest przez komendę SELECT. Potrafi ona być bardzo skomplikowana, my jednak pokażemy w tym dokumencie tylko trzy główne jej formy:

Wybranie wszystkich informacji z tabeli
SELECT * FROM tabela;
Wybranie konkretnych informacji z tabeli
SELECT * FROM tabela WHERE pole=wartość;
Wybranie konkretnych pól
SELECT pole1,pole2,pole3 FROM tabela [WHERE pole=wartość];

Przyjrzyjmy się teraz pierwszej formie. Jest ona całkiem prosta i daje w wyniku ogólny wgląd w tabelę. Zobaczmy zatem jakie dane zawiera nasza tabela do tej pory:

mysql> SELECT * FROM developers;
+-------------+-----------------------+---------------+
| name        | email                 | job           |
+-------------+-----------------------+---------------+
| Joe Smith   | joesmith@gentoo.org   | toolchain     |
| John Doe    | johndoe@gentoo.org    | portage       |
| Chris White | chriswhite@gentoo.org | documentation |
| Sam Smith   | samsmith@gentoo.org   | amd64         |
+-------------+-----------------------+---------------+
4 rows in set (0.00 sec)

Widzimy tutaj zarówno dane wprowadzone za pomocą polecenia INSERT jak i te wprowadzone poprzez LOAD DATA. A teraz, powiedzmy że chcemy zobaczyć tylko rekord dewelopera o nazwisku Chris White. Możemy to zrobić używając drugiej formy zapytania:

mysql> SELECT * FROM developers WHERE name = 'Chris White';
+-------------+-----------------------+---------------+
| name        | email                 | job           |
+-------------+-----------------------+---------------+
| Chris White | chriswhite@gentoo.org | documentation |
+-------------+-----------------------+---------------+
1 row in set (0.08 sec)

Tak jak się spodziewaliśmy, wybrany przez nas deweloper został wyświetlony. A teraz, powiedzmy że chcemy znać tylko zadania i adres email pewnej osoby, ale nie potrzebne nam jej nazwisko. Użyjmy do tego zadania trzeciej formy polecenia SELECT:

mysql> SELECT email,job FROM developers WHERE name = 'Chris White';
+-----------------------+---------------+
| email                 | job           |
+-----------------------+---------------+
| chriswhite@gentoo.org | documentation |
+-----------------------+---------------+
1 row in set (0.04 sec)

Będąc zalogowanym w bazie MySQL jako użytkownik root, mamy nieograniczone prawa do wszystkiego czego możemy sobie zażyczyć. W środowisku serwera, użytkownik z takimi przywilejami może być nieco problematyczny. Aby kontrolować kto i co robi z bazami danych przyznamy teraz odpowiednim użytkownikom odpowiednie przywileje.

4.  Przywileje MySQL

Przyznawanie uprawnień za pomocą polecenia GRANT

Uprawnienia określają jaki rodzaj dostępu do baz danych, tabel, itd. posiadają użytkownicy MySQL. W tej chwili na przykład jedynym użytkownikiem mającym dostęp do niedawno stworzonej bazy gentoo jest root. Stwórzmy teraz zatem jeszcze dwóch użytkowników, guest oraz admin, którzy będą mieli dostęp do bazy gentoo i informacji w niej zawartych. Sprawimy, że użytkownik guest będzie miał bardzo ograniczone prawa, pozwolimy mu tylko i wyłącznie na pobieranie informacji z bazy. admin będzie posiadał dokładnie takie same uprawnienia jak root, jednak tylko w stosunku do bazy gentoo, nie będzie miał żadnej możliwości ingerencji w inne bazy, a w szczególności w bazę mysql. Zanim rozpoczniemy, przyjrzyjmy się bliżej nieco uproszczonej formie polecenia GRANT:

GRANT [przywilej] ON baza_danych.* TO '[użytkownik]'@'[host]' IDENTIFIED BY '[hasło]';

Pierwszym argumentem jaki będziemy musieli podać są przywileje jakie chcemy nadać użytkownikowi. Poniżej została podana lista możliwych do nadania uprawnień uwzględniająca to czego się do tej pory nauczyliśmy:

• ALL - Użytkownik otrzymuje wszystkie przywileje za wyjątkiem GRANT OPTION
• CREATE - Pozwala użytkownikowi na tworzenie tabel
• SELECT - Pozwala na przeszukiwanie tabel
• INSERT - Pozwala dodawać nowe informacje do tabel
• SHOW DATABASES - Pozwala użytkownikowi na przeglądanie listy dostępnych baz danych
• USAGE - Służy do tworzenia użytkownika bez uprawnień
• GRANT OPTION - Pozwala użytkownikowi nadawać uprawnienia.

Zatem użytkownikowi admin nadamy uprawnienia ALL. Dla użytkownika guest SELECT będzie wystarczające do dostępu tylko do odczytu. baza_danych jest bazą danych do której chcemy, aby użytkownik miał uprawnienia. W naszym przykładzie, gentoo będzie właśnie tą bazą. Kolejne dwa znaki .* oznaczają wszystkie tabele w naszej bazie. Jeżeli zajdzie taka potrzeba można w miejsce * zdefiniować dostęp tylko do określonych tabel w bazie. użytkownik jest nazwą użytkownika, natomiast host to nazwa komputera z którego użytkownik będzie miał dostęp. W większości przypadków będzie to po prostu localhost. Wreszcie hasło jest hasłem jakim użytkownik będzie się musiał uwierzytelnić. Kiedy już skończymy nadawanie uprawnień, będziemy musieli wykonać polecenie FLUSH PRIVILEGES. Spowoduje ono aktualizację uprawnień bez konieczności ponownego uruchomienia serwera MySQL. Wszystko mamy zaplanowane, przejdźmy zatem do stworzenia nowych użytkowników:

admin
mysql> GRANT ALL ON gentoo.* TO 'admin'@'localhost' IDENTIFIED BY 'hasło';
guest
mysql> GRANT SELECT ON gentoo.* TO 'guest'@'localhost' IDENTIFIED BY 'hasło';

Teraz, kiedy nowi użytkownicy zostali dodani, przetestujmy ich konta. Opuśćmy teraz konsolę MySQL wpisując quit w wierszu poleceń.

mysql> quit

Jesteśmy teraz w konsoli systemu. Mając utworzonych nowych użytkowników sprawdźmy do czego tak naprawdę mają dostęp.

Testowanie uprawnień użytkowników

Ponieważ wróciliśmy do konsoli systemowej, spróbujemy zalogować się teraz na konto guest. W tej chwili, użytkownik guest powinien posiadać przywilej tylko do polecenia SELECT. Sprowadza się to do możliwości przeszukiwania bazy i niczego więcej. Zalogujmy się więc jako użytkownik guest:

$ mysql -u guest -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 6 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Przetestujmy czy faktycznie nasz użytkownik ma nałożone odpowiednie restrykcje. Najpierw przekażemy systemowi, że chcemy pracować na bazie gentoo:

mysql> USE gentoo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

Sprawdzimy teraz coś do czego nie powinniśmy mieć uprawnień. Spróbujemy stworzyć tabelę:

mysql> CREATE TABLE test (test VARCHAR(20), foobar VARCHAR(2));
ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'

Polecenie zakończyło się niepowodzeniem, ponieważ użytkownik nie posiada odpowiednich uprawnień. Jak pamiętamy, nadaliśmy użytkownikowi guest prawo do polecenia SELECT. Sprawdźmy je teraz:

mysql> SELECT * FROM developers;
+-------------+-----------------------+---------------+
| name        | email                 | job           |
+-------------+-----------------------+---------------+
| Joe Smith   | joesmith@gentoo.org   | toolchain     |
| John Doe    | johndoe@gentoo.org    | portage       |
| Chris White | chriswhite@gentoo.org | documentation |
| Sam Smith   | samsmith@gentoo.org   | amd64         |
+-------------+-----------------------+---------------+
4 rows in set (0.01 sec)

Zgodnie z oczekiwaniami polecenie zostało wykonane poprawnie. Oprócz konta guest, stworzyliśmy także konto admin. Stworzyliśmy je, aby pokazać, że nawet konto z przywilejem ALL ciągle posiada swoje ograniczenia. Opuśćmy zatem konsolę MySQL i zalogujmy się jako użytkownik admin:

mysql> quit
Bye
$ mysql -u admin -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
 Your MySQL connection id is 7 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Na początku spróbujemy stworzyć nową bazę danych. Nasz użytkownik, admin, posiada bardzo podobne uprawnienia do konta root, zatem może wykonywać dowolne zmiany w bazie gentoo. Pamiętamy jednak, że nadaliśmy użytkownikowi admin uprawnienia tylko do jednej konkretnej bazy. Sprawdźmy zatem czy tak jest w rzeczywistości:

mysql> CREATE DATABASE gentoo2;
ERROR 1044: Access denied for user: 'admin@localhost' to database 'gentoo2'

Rzeczywiście, użytkownik admin nie może tworzyć nowych baz danych, pomimo tylu uprawnień w bazie gentoo. Jednak możemy ciągle użyć konta admin do modyfikacji bazy gentoo, jak zostało to pokazane na poniższym przykładzie:

mysql> USE gentoo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> INSERT INTO developers VALUES('Bob Simmons', 'bobsimmons@gentoo.org', 'python');
Query OK, 1 row affected (0.08 sec)

Istotnie użytkownik admin może swobodnie modyfikować bazę gentoo, jeśli tylko zechce. Czasami zachodzi potrzeba odebrania użytkownikom uprawnień, powodem może być zarówno problematyczny użytkownik jak i pracownik na emeryturze. Zobaczmy jak można odbierać uprawnienia za pomocą polecenia REVOKE.

Odbieranie uprawnień za pomocą komendy REVOKE

Komenda REVOKE pozwala na odbieranie uprawnień użytkownikom. Możliwe jest zarówno odebranie jakiegoś konkretnego uprawnienia, jak i wszystkich możliwych. Składnia polecenia REVOKE jest bardzo podobna do polecenia GRANT:

REVOKE [przywilej] ON baza_danych.* FROM '[użytkownik]'@'[host]';

Argumenty tego polecenia zostały już omówione w sekcji dotyczącej polecenia GRANT. Tutaj natomiast zostanie przedstawiony proces odbierania wszystkich uprawnień. Powiedzmy, że dowiadujemy się o pewnych nadużyciach związanych z bezpieczeństwem ze strony użytkownika guest. Decydujemy się na odebranie mu wszystkich uprawnień.

mysql> REVOKE ALL ON gentoo.* FROM 'guest'@'localhost';
Query OK, 0 rows affected (0.00 sec)

Opuścimy teraz konto root i zalogujemy się jako guest:

$ mysql -u guest -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 9 to server version: 4.0.24-debug

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Jak się okazuje, użytkownik dalej jest w stanie zalogować się do systemu. Jednak jego prawa dostępu do bazy gentoo już nie istnieją:

mysql> USE gentoo;
ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'

W ten sposób użytkownik sprawiający problemy nie ma już dostępu do bazy gentoo. Należy jednak zauważyć, że ciągle jest on w stanie zalogować się do serwera baz danych. Dzieje się tak, ponieważ pozostaje on ciągle wpisany do głównej bazy MySQL. Zobaczymy teraz jak można całkowicie usunąć konto użytkownika z systemu za pomocą polecenia DELETE oraz głównej tabeli MySQL.

Całkowite usuwanie kont za pomocą polecenia DELETE i tabeli user głównej bazy MySQL.

Tabela user głównej bazy MySQL zawiera listę wszystkich użytkowników systemu oraz informacje o nich. Upewniamy się, że jesteśmy zalogowani jako root, a następnie przystępujemy do pracy z główną bazą.

mysql> USE mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql>

Zobaczmy jakie tabele zawiera baza mysql:

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mysql |
+-----------------+
| columns_priv    |
| db              |
| func            |
| host            |
| tables_priv     |
| user            |
+-----------------+
6 rows in set (0.00 sec)

Tabela user jest tą o którą nam chodziło. Jednak zawiera ona 30 różnych pól, co czyni ją trudną w przeglądaniu. Do wyświetlenia danych z tej tabeli w przystępnej i czytelnej formie posłuży tutaj trzecia forma polecenia SELECT. Pola które chcielibyśmy zobaczyć to Host oraz User.

mysql> SELECT Host,User FROM user WHERE User = 'guest';
+-----------+-------+
| Host      | User  |
+-----------+-------+
| localhost | guest |
+-----------+-------+
1 row in set (0.00 sec)

Po odnalezieniu użytkownika, można w końcu usunąć go całkowicie z systemu. Służy do tego polecenie DELETE, którego składnia przedstawiona została poniżej:

DELETE FROM tabela WHERE pole='wartość';

Można zauważyć, że składnia polecenia DELETE jest niejako podobna do polecenia SELECT. W tym przypadku pole będzie równe User natomiast wartość guest. Tak skonstruowane polecenie usunie z tabeli rekord, w którym pole User jest równe guest, usuwając w ten sposób definitywnie konto guest z systemu:

mysql> DELETE FROM user WHERE User='guest';
Query OK, 1 row affected (0.07 sec)
Polecenie FLUSH PRIVILEGES jest konieczne, aby zmiany w uprawnieniach
odniosły skutek
mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Można teraz sprawdzić czy zmiany odniosły oczekiwany skutek poprzez próbę zalogowania się jako użytkownik guest:

mysql> quit
Bye
$ mysql -u guest -h localhost -p
Enter password:
ERROR 1045: Access denied for user: 'guest@localhost' (Using password: YES)

Użytkownik został całkowicie usunięty z bazy!

Podsumowanie

Chociaż przewodnik ten był nastawiony na konfigurację MySQL z linii komend, istnieje kilka alternatyw z interfejsem graficznym:

• phpMyAdmin - Popularne narzędzie do administrowania serwerem MySQL zbudowane w technologii php
• mysqlnavigator Kolejny interfejs internetowy do administracji serwerem MySQL
• gmyclient - Klient MySQL oparty o środowisko GNOME
• knoda - Klient MySQL oparty o środowisko KDE.

W ten sposób dotarliśmy do końca tego krótkiego wprowadzenia do MySQL. Mam nadzieję, że było ono pomocne w zrozumieniu jednego z najpopularniejszych dziś serwerów baz danych. Jeżeli masz jakiekolwiek uwagi na temat tego dokumentu nie wahaj się napisać do mnie.

Materiał udostępniany na podstawie licencji Creative Commons - Attribution / Share Alike.