Zrównoważony rozwój w biznesie jest trudny bez odpowiedniego zarządzania danymi. Zbudowanie dobrze zdefiniowanego systemu jest niezbędne do zarządzania operacjami wewnętrznymi i zewnętrznymi. Szczegółowy wgląd w dane biznesowe pomaga zrozumieć ogólny przepływ pracy i mierzyć wydajność. Co więcej, korzystanie z baz danych oszczędza czas i pozwala na bezproblemowy dostęp do informacji.
Co to jest baza danych?
Baza danych to zorganizowany system służący do bezpiecznego przechowywania informacji. Oferuje kategoryzację i pozwala na tworzenie tabel w celu sortowania podobnych rodzajów elementów w ramach jednej grupy. Tabele zapewniają opcje wyświetlania informacji w wielu wierszach i kolumnach. W rezultacie poprawia się jakość i spójność danych. Oprócz możliwości przechowywania i łatwego dostępu, bazy danych odgrywają znaczącą rolę w ochronie prywatności i zabezpieczaniu systemów. Niezależnie od tego, czy jest to działanie ad hoc, czy część procesu zakodowanego w aplikacji, pobieranie danych jest jednym z najważniejszych aspektów zarządzania bazą danych.
A Zapytanie w relacyjnym DMS to dowolne polecenie służące do pobierania danych z tabeli. SELECT instrukcje są prawie zawsze używane w Structured Query Language (SQL). Istnieje kilka metod pobierania informacji z bazy danych. Zazwyczaj programiści preferują opcję linii poleceń, ponieważ jest szybka i efektywna. Pozwala na bezproblemowe przesyłanie zapytań.
W tym poradniku wprowadzimy Cię do MySQL i omówimy, jak pracować z zapytaniami w MySQL. Zacznijmy!
Wymagania wstępne
Aby móc śledzić ten samouczek, będziesz potrzebować:
-
Najnowsza wersja Ubuntu jest zainstalowany w Twoim systemie.
-
Użytkownicy systemu muszą posiadać uprawnienia sudo.
-
Jeśli napotkasz trudności z dostępem do swojego konta sudo, rozważ zmianę hasła roota MySQL.
-
-
MySQL jest skonfigurowany na Twoim serwerze.
Krok 1 — Tworzenie i konfiguracja bazy danych
Zanim zaczniemy i napiszemy nasze pierwsze zapytanie SQL, musimy utworzyć bazę danych i dodać do niej tabele. Następnie wypełnimy tabele przykładowymi danymi. Praca z bazami danych pomoże Ci zrozumieć podstawową konfigurację i nabrać pewności w pracy z zapytaniami.
Doświadczenie praktyczne to najskuteczniejszy sposób na budowanie pojęć i zrozumienie znaczenia baz danych. W tym poradniku przeprowadzimy Cię przez korzystanie z baz danych i ich znaczenie w rozwiązywaniu rzeczywistych problemów. Sprawdźmy scenariusz, aby zrozumieć, jak bazy danych mogą pomóc w organizowaniu rekordów w ustrukturyzowany sposób.
Scenariusz: Utworzymy bazę danych, w której grupa studentów wyjeżdża na wakacje, aby uczcić swoje urodziny. Przed wyjazdem na urlop planują wziąć udział w towarzyskich zawodach pływackich. Ponadto każdy znajomy w grupie planuje listę zadań do wykonania, aby ich podróż była ekscytująca i przyjemna.
Najpierw otwórz MySQL jako użytkownik root:
|
1 |
$ sudo mysql |
Następnie utwórz bazę danych, uruchamiając następujące polecenie:
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Query OK, 1 row affected (0.52 sec) |
Następnie użyjmy naszej bazy danych za pomocą następującego polecenia:
|
1 |
mysql> USE vacation; |
Następnie utworzymy tabele w naszej bazie danych. Nazwij pierwszą tabelę jako celebration. Nasza tabela będzie miała kolumny na imiona naszych znajomych (name), wygrane przez nich turnieje (wins) a także kolumnę na ich najlepszy czas (time):
|
1 2 3 4 5 6 7 |
mysql> CREATE TABLE celebration ( -> name varchar(50), -> wins real, -> time real -> ); Query OK, 0 rows affected (2.03 sec) |
Następnie wypełnimy naszą tabelę danymi:
|
1 2 3 4 5 6 7 8 9 |
mysql> INSERT INTO celebration (name, wins, time) VALUES('Austin', '4', '15.5'), ('Ivan','7','9'), ('Aisha','10','5'), ('Zane','13','7.5'); Query OK, 4 rows affected (0.29 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Następnie utwórz kolejną tabelę w naszej bazie danych, aby przechowywać informacje o ich ulubionych aktywnościach urodzinowych. Utworzymy tabelę o nazwie vacation i będzie ona miała następujące kolumny:
|
Lista |
Szczegóły |
|
name: |
Przechowuje imię każdego przyjaciela. |
|
birthdate: |
Śledzi datę urodzenia każdej osoby. |
|
activity: |
Rejestruje ich ulubioną aktywność. |
|
Cel podróży: |
Przechowuje informacje o ulubionym celu podróży każdej osoby. |
|
meal: |
Śledzi ulubiony posiłek danej osoby. |
|
1 2 3 4 5 6 7 8 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) |
Zapełnij tabelę danymi:
|
1 2 3 4 5 6 7 8 9 10 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Konfiguracja bazy danych została zakończona.
Krok 2 — Wprowadzenie do instrukcji SELECT
Zapytania w SQL zazwyczaj zaczynają się od SELECT. Służy ono w zapytaniach do określenia, które kolumny z tabeli powinny zostać zwrócone w wynikach. Zapytanie musi również zawsze zawierać FROM, które służy do wskazania tabeli, z której instrukcja będzie pobierać dane.
Zapytania mają następującą składnię:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
Użyjemy składni zapytania, aby zwrócić kolumnę meal z tabeli vacation:
|
1 |
mysql> SELECT meal FROM vacation; |
Wynik będzie następujący:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Fries | | Tofu | +-------+ 4 rows in set (0.00 sec) |
Możesz również wybrać wiele kolumn, rozdzielając je przecinkiem:
|
1 |
mysql> SELECT name, destination FROM vacation; |
Wynik:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+-------------+ | name | destination | +--------+-------------+ | Austin | Maldives | | Ivan | Mauritius | | Aisha | Colorado | | Zane | Bora Bora | +--------+-------------+ 4 rows in set (0.00 sec) |
Możesz również użyć gwiazdki (*), jeśli chcesz wyświetlić wszystkie kolumny w tabeli:
|
1 |
mysql> SELECT * FROM celebration; |
Wynik:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------+ | name | wins | time | +--------+------+------+ | Austin | 4 | 15.5 | | Ivan | 7 | 9 | | Aisha | 10 | 5 | | Zane | 13 | 7.5 | +--------+------+------+ 4 rows in set (0.00 sec) |
Jeśli chcesz przefiltrować rekordy spełniające określony warunek, używasz WHERE. Wiersze, które nie spełniają określonego warunku, są usuwane z wyników. Klauzula WHERE używa następującej składni:
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
Jest to operator porównania, który określa, w jaki sposób wskazana kolumna powinna być porównywana z wartością. Typowe operatory porównania w SQL to:
|
Operator |
Zastosowanie |
|
= |
Równość |
|
!= |
Nierówność |
|
< |
Mniejsze niż |
|
> |
Większe niż |
|
<= |
Mniejsze lub równe |
|
>= |
Większe lub równe |
|
BETWEEN |
Sprawdza, czy wartość mieści się w podanym zakresie. |
|
IN |
Sprawdza, czy wartość wiersza znajduje się w zestawie określonych wartości. |
|
EXISTS |
Sprawdza, czy wiersz istnieje |
|
LIKE |
Sprawdza, czy wartość pasuje do określonego ciągu znaków |
|
IS NULL |
Sprawdza wartości null |
|
IS NOT NULL |
Sprawdza wszystkie wartości inne niż NULL |
Jeśli chcesz znaleźć ulubiony cel podróży Aishy, możesz użyć poniższego zapytania:
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
Zapytanie zwróci wówczas:
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 wiersz w zestawie (0.03 sek) |
SQL obsługuje użycie znaków wieloznacznych, które są szczególnie przydatne w WHERE klauzulach. Znaki procenta ( %) oznaczają zero lub więcej nieznanych znaków, podczas gdy podkreślenia ( _) oznaczają pojedynczy nieznany znak. Są one pomocne, jeśli chcesz znaleźć konkretny wpis w tabeli, ale nie masz co do niego pewności.
Na przykład, jeśli zapomniałeś ulubionego celu podróży przyjaciela i znałeś tylko literę, od której się zaczyna, na przykład “m”, możesz znaleźć nazwę celu podróży za pomocą następującego zapytania:
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
Zapytanie zwróci:
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Maldives | | Mauritius | +-------------+ 2 wiersze w zestawie (0.04 sek) |
Podczas pracy z bazami danych możesz napotkać kolumny lub tabele o stosunkowo długich lub trudnych do odczytania nazwach. W takich przypadkach możesz uczynić te nazwy bardziej czytelnymi, używając słowa kluczowego AS do utworzenia aliasu. Aliasy utworzone za pomocą AS są ważne tylko przez czas trwania zapytania, dla którego zostały utworzone:
|
1 2 3 4 5 6 7 8 9 10 11 |
mysql> SELECT name AS E, destination as D, activity as A FROM vacation; +--------+-----------+-------------------+ | E | D | A | +--------+-----------+-------------------+ | Austin | Maldives | skiing | | Ivan | Mauritius | paragliding | | Aisha | Colorado | mountain climbing | | Zane | Bora Bora | fishing | +--------+-----------+-------------------+ 4 wiersze w zestawie (0.00 sek) |
Krok 3 — Wprowadzenie do funkcji agregujących
Podczas pracy z danymi nie zawsze chcesz widzieć same dane. Wolisz raczej uzyskać informacje o danych. Poprzez wydanie zapytania SELECT możesz interpretować lub wykonywać obliczenia na swoich danych przy użyciu składni SQL. Są one określane jako funkcje agregujące.
Funkcja COUNT zlicza i zwraca liczbę wierszy spełniających określony zestaw kryteriów. Na przykład, jeśli chcesz wiedzieć, ilu znajomych woli udać się do Maldives, możesz użyć następującego zapytania:
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Maldives'; |
Zostaną zwrócone następujące wyniki:
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 wiersz w zestawie (0.06 sek) |
MIN służy do znajdowania najmniejszej wartości w określonej kolumnie:
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
Zapytanie zwróci wynik:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 wiersz w zestawie (0.02 sek) |
MAX służy do znajdowania największej wartości liczbowej w danej kolumnie:
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
Oczekiwany wynik to:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 wiersz w zestawie (0.03 sek) |
Zarówno funkcja MIN jak i MAX mogą być używane do danych liczbowych i alfabetycznych. Po zastosowaniu do kolumny z wartościami tekstowymi, funkcja MIN zwraca pierwszą wartość pod względem alfabetycznym.
Funkcja MIN zwraca pierwszą wartość alfabetycznie:
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
Oto jak będzie wyglądać wynik:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 wiersz w zestawie (0.00 sek) |
Funkcja MAX zwraca ostatnią wartość alfabetycznie:
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
Oto jak będzie wyglądać wynik:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 wiersz w zestawie (0.00 sek) |
Krok 4 — Manipulowanie wynikami zapytań
Inną popularną klauzulą, która jest używana, jest GROUP BY. Jest ona używana podczas wykonywania funkcji agregującej na jednej kolumnie, ale w odniesieniu do pasujących wartości w innej:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
Wynik będzie następujący:
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | narciarstwo | | 1 | paralotniarstwo | | 1 | wspinaczka górska | | 1 | wędkarstwo | +-------------+-------------------+ 4 wiersze w zestawie (0.04 sek) |
Aby posortować wyniki zapytania, użyj klauzuli ORDER BY. Wartości liczbowe są domyślnie sortowane rosnąco, natomiast wartości tekstowe są sortowane alfabetycznie. Poniższe zapytanie wyświetla kolumny name i birthdate, ale sortuje wyniki według birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
Wynik będzie następujący:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Zane | 1996-01-01 | | Aisha | 1999-07-24 | | Austin | 2002-01-07 | | Ivan | 2010-12-18 | +--------+------------+ 4 wiersze w zestawie (0.04 sek) |
Wynik jest w porządku rosnącym; aby posortować w porządku malejącym, zakończ zapytanie słowem DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Spójrz na wynik:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Ivan | 2010-12-18 | | Austin | 2002-01-07 | | Aisha | 1999-07-24 | | Zane | 1996-01-01 | +--------+------------+ 4 wiersze w zestawie (0.00 sek) |
Klauzula HAVING została dodana do SQL, aby zapewnić funkcjonalność podobną do klauzuli WHERE, będąc jednocześnie kompatybilną z funkcjami agregującymi. Różnica między tymi dwiema klauzulami polega na tym, że WHERE służy do odwoływania się do pojedynczych rekordów, a HAVING odnosi się do rekordów grupowych. W tym celu klauzula GROUP BY musi być obecna zawsze, gdy używana jest klauzula HAVING:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
Zapytanie zwróci:
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | narciarstwo | | 1 | paralotniarstwo | | 1 | wspinaczka górska | | 1 | wędkarstwo | +-------------+-------------------+ |
Wartość COUNT wynosi 1 dla wszystkich, ponieważ żadnych dwoje znajomych nie lubi tej samej aktywności.
Krok 5 — Zapytania do wielu tabel
Klauzula JOIN może być użyta w wyniku zapytania do połączenia wierszy z dwóch lub więcej tabel. Osiąga to poprzez zlokalizowanie powiązanej kolumny między tabelami i odpowiednie posortowanie wyniku.
SELECT instrukcje, które zawierają klauzulę JOIN, są zgodne z poniższą składnią:
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Gdybyś chciał kupić każdemu ze swoich znajomych puchar za ich zwycięstwa podczas pływania w ich urodziny, możesz utworzyć zapytanie, które połączy obie tabele, aby pomóc Ci znaleźć wszystkie potrzebne informacje za pomocą jednego zapytania:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
Wynik będzie następujący:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 rows in set (0.00 sec) |
To jest wewnętrzna klauzula JOIN. Wynika to z faktu, że wybiera ona wszystkie rekordy, które mają pasujące wartości w obu tabelach, i wypisuje je w zestawie wyników. Rekordy, które nie pasują do zapytania, nie są uwzględniane. Możemy dodać do naszych tabel nowy wiersz, który nie odpowiada żadnemu wpisowi:
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 row affected (0.01 sec) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 row affected (0.01 sec) |
Następnie uruchom ponownie instrukcję SELECT z klauzulą JOIN:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate -> FROM celebration -> JOIN vacation ON celebration.name=vacation.name; +--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 rows in set (0.00 sec) |
Ponieważ tabela celebration nie ma wpisu dla Petera, a tabela vacation nie ma wpisu dla Elli, rekordy te są nieobecne.
Możemy zwrócić wszystkie rekordy z jednej z tabel, używając zewnętrznej klauzuli JOIN. Może to być LEFT JOIN lub RIGHT JOIN. Klauzula LEFT JOIN zwraca wszystkie rekordy z lewej tabeli i tylko dopasowane rekordy z prawej tabeli. Lewa tabela w kontekście złączeń zewnętrznych to ta, do której odwołuje się klauzula FROM, a prawa tabela to dowolna tabela wskazana po instrukcji JOIN.
Uruchom zapytanie ponownie, ale użyj klauzuli LEFT JOIN:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
Polecenie zwróci wszystkie rekordy z lewej tabeli ( celebration) nawet jeśli nie ma ona odpowiadającego jej rekordu w prawej tabeli. Gdy w prawej tabeli nie ma pasującego rekordu, jest on zwracany jako NULL:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | Ella | 1 | NULL | +--------+------+------------+ 5 rows in set (0.00 sec) |
To jest teraz klauzula RIGHT JOIN:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration RIGHT JOIN vacation ON celebration.name=vacation.name; |
Zwrócone zostaną wszystkie wartości z prawej tabeli (vacation). Ponieważ birthdate Petera jest zapisana w prawej tabeli, a w lewej tabeli nie ma jego name ani wins, kolumny te zwrócą wartości NULL w tych wierszach:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | NULL | NULL | 1991-05-03 | +--------+------+------------+ 5 wierszy w zestawie (0.01 sek) |
Możesz użyć klauzuli UNION zamiast JOIN, aby pobierać rekordy z wielu tabel. Operator UNION różni się od klauzuli JOIN tym, że łączy wyniki dwóch instrukcji SELECT w jedną kolumnę, zamiast wyświetlać wyniki z wielu tabel jako unikalne kolumny przy użyciu pojedynczej instrukcji SELECT.
Możesz uruchomić to zapytanie, aby to zilustrować:
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
Zapytanie usuwa zduplikowane wpisy. Jest to domyślne zachowanie operatora UNION :
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 wierszy w zestawie (0.00 sek) |
Aby zwrócić wszystkie wpisy (wraz z duplikatami), użyj operatora UNION ALL :
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Wynik:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Austin | | Ivan | | Aisha | | Zane | | Peter | +--------+ 10 wierszy w zestawie (0.00 sek) |
Podzapytania to kolejna metoda odpytywania wielu tabel. Podzapytania to zapytania, które są zagnieżdżone wewnątrz innego zapytania (znane również jako zapytania wewnętrzne lub zagnieżdżone). Są one przydatne, gdy chcesz porównać wyniki zapytania z wynikami oddzielnej funkcji agregującej.
Użyjemy przykładu, w którym próbujemy dowiedzieć się, który ze znajomych wygrał więcej turniejów pływackich niż Ella. Zamiast sprawdzać, ile meczów wygrała Ella, a następnie uruchamiać kolejne zapytanie, aby zobaczyć, kto wygrał więcej gier, możesz obliczyć jedno i drugie za pomocą pojedynczego zapytania:
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
Zapytanie zwróci:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | name | wins | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 wierszy w zestawie (0.06 sek) |
Jeśli chcesz zabrać swoich znajomych na niespodziewane wakacje, możesz użyć zapytania, aby sprawdzić, kto ma najwięcej wygranych i zwrócić cel ich podróży:
|
1 2 3 4 |
mysql> SELECT name, destination, activity, meal -> FROM vacation -> WHERE name = ( SELECT name FROM celebration -> WHERE wins = (SELECT MAX(wins) FROM celebration)); |
Zapytanie zwróci:
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | name | destination | activity | meal | +------+-------------+----------+------+ | Zane | Bora Bora | fishing | Tofu | +------+-------------+----------+------+ 1 wiersz w zestawie (0.00 sek) |
To zapytanie zawiera podzapytanie wewnątrz podzapytania.
Podsumowanie
Generowanie zapytań to jedno z najczęstszych zadań w zarządzaniu bazami danych. Istnieje kilka narzędzi do administracji bazami danych, takich jak phpMyAdmin i pgAdmin, których można używać do pracy z zapytaniami i wizualizacji ich wyników. Jednak instrukcja SELECT z poziomu wiersza poleceń jest najchętniej wybieranym rozwiązaniem ze względu na łatwość użycia i doskonałą kontrolę.
Ponadto istnieje wiele samouczków dotyczących baz danych, które możesz poznać na naszym blogu:
- SQLite vs MySQL vs. PostgreSQL: Porównanie relacyjnych systemów zarządzania bazami danych
- Szybkie rozwiązania naprawy uszkodzonych tabel w MySQL: Poradnik
- Jak zainstalować MySQL na Centos 7
- Użytkownik MySQL — Tworzenie i nadawanie uprawnień
- Konfiguracja replikacji w MySQL na Ubuntu
Miłego korzystania z komputera!
Komentarze
Brak komentarzy. Bądź pierwszy.