Udržateľnosť v podnikaní je bez správnej správy údajov náročná. Vybudovanie dobre definovaného systému je nevyhnutné na riadenie interných a externých operácií. Podrobný prehľad o obchodných údajoch pomáha pochopiť celkový pracovný postup a merať výkonnosť. Používanie databáz navyše šetrí čas a umožňuje bezproblémový prístup k informáciám.
Čo je to databáza?
A Databáza je organizovaný systém používaný na bezpečné ukladanie informácií. Ponúka kategorizáciu a umožňuje vytváranie tabuliek na triedenie podobných druhov položiek do jednej skupiny. Tabuľky poskytujú možnosti na zobrazenie informácií vo viacerých riadkoch a stĺpcoch. V dôsledku toho sa zlepšuje kvalita a konzistentnosť údajov. Okrem úložiska a jednoduchého prístupu zohrávajú databázy významnú úlohu pri ochrane súkromia a zabezpečení systémov. Či už ad hoc, alebo ako súčasť procesu zakódovaného do aplikácie, získavanie údajov je jedným z najdôležitejších aspektov správy databáz.
A Dopyt v relačnom DMS je akýkoľvek príkaz používaný na získanie údajov z tabuľky. SELECT príkazy sa takmer vždy používajú v dopytoch v Structured Query Language (SQL). Existuje niekoľko metód na získanie informácií z databázy. Vývojári vo všeobecnosti uprednostňujú možnosť príkazového riadka, pretože je rýchla a efektívna. Umožňuje bezproblémové odosielanie dopytov.
V tejto príručke vás zoznámime s MySQL a povieme si, ako pracovať s dopytmi v MySQL. Začnime!
Predpoklady
Na absolvovanie tohto návodu budete potrebovať nasledovné:
-
Najnovšia verzia Ubuntu je nainštalovaná vo vašom systéme.
-
Systémoví používatelia musia mať práva sudo.
-
Ak máte problémy s prístupom k svojmu účtu sudo, zvážte zmenu hesla root pre MySQL.
-
-
MySQL je nastavené na vašom serveri.
Krok 1 — Vytvorenie a nastavenie databázy
Predtým, ako začneme a napíšeme náš prvý SQL dopyt, musíme vytvoriť databázu a pridať do nej tabuľky. Potom tabuľky naplníme vzorovými údajmi. Práca s databázami vám pomôže pochopiť základné nastavenie a dodá vám istotu pri práci s dopytmi.
Praktické skúsenosti sú najefektívnejším spôsobom, ako si vybudovať koncepty a pochopiť dôležitosť databáz. V tejto príručke vás prevedieme používaním databáz a ich významom pri riešení reálnych problémov. Pozrime sa na scenár, aby sme pochopili, ako môžu databázy pomôcť organizovať záznamy štruktúrovaným spôsobom.
Scenár: Vytvoríme databázu, v ktorej skupina vysokoškolákov odchádza na dovolenku osláviť svoje narodeniny. Pred odchodom na dovolenku plánujú účasť v priateľskej plaveckej súťaži. Každý kamarát v skupine si tiež naplánuje zoznam úloh a aktivít, aby bol ich výlet vzrušujúci a príjemný.
Najprv otvorte MySQL ako používateľ root:
|
1 |
$ sudo mysql |
Potom vytvorte databázu spustením nasledujúceho príkazu:
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Query OK, 1 row affected (0.52 sec) |
Ďalej použijeme našu databázu pomocou nasledujúceho príkazu:
|
1 |
mysql> USE vacation; |
Potom v našej databáze vytvoríme tabuľky. Prvú tabuľku pomenujte ako celebration. Naša tabuľka bude mať stĺpce pre mená našich kamarátov (name), turnaje, ktoré vyhrali (wins) a tiež stĺpec pre ich najlepší čas (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) |
Potom našu tabuľku naplníme údajmi:
|
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 |
Potom v našej databáze vytvorte ďalšiu tabuľku na ukladanie informácií o ich obľúbených narodeninových aktivitách. Vytvoríme tabuľku s názvom vacation a bude mať nasledujúce stĺpce:
|
Zoznam |
Detail |
|
name: |
Uloží meno každého priateľa. |
|
birthdate: |
Sleduje dátum narodenia každého jednotlivca. |
|
activity: |
Uchováva záznam o ich obľúbenej aktivite. |
|
Destinácia: |
Ukladá informácie o obľúbenej destinácii každého jednotlivca. |
|
meal: |
Sleduje obľúbené jedlo jednotlivca. |
|
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) |
Naplňte tabuľku údajmi:
|
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 |
Teraz ste dokončili nastavenie svojej databázy.
Krok 2 — Začíname s príkazmi SELECT
Dopyty v SQL zvyčajne začínajú s SELECT. Používa sa v dopytoch na určenie toho, ktoré stĺpce v tabuľke sa majú vrátiť s výsledkami. Dopyt musí tiež vždy obsahovať FROM, ktorý sa používa na určenie tabuľky, na ktorú sa bude dopytovať príkaz.
Dopyty majú nasledujúcu syntax:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
Použijeme syntax dopytu na vrátenie stĺpca meal z tabuľky vacation:
|
1 |
mysql> SELECT meal FROM vacation; |
Náš výstup bude nasledujúci:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Fries | | Tofu | +-------+ 4 rows in set (0.00 sec) |
Môžete tiež vybrať viacero stĺpcov tak, že ich oddelíte čiarkou:
|
1 |
mysql> SELECT name, destination FROM vacation; |
Výstup:
|
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) |
Môžete tiež použiť asterisk (*), ak chcete reprezentovať všetky stĺpce v tabuľke:
|
1 |
mysql> SELECT * FROM celebration; |
Výstup:
|
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) |
Ak chcete filtrovať záznamy, ktoré spĺňajú zadanú podmienku, použite WHERE. Riadky, ktoré nespĺňajú zadanú podmienku, sú z výsledkov vylúčené. Klauzula WHERE používa nasledujúcu syntax:
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
Je to porovnávací operátor, ktorý definuje, ako sa má špecifikovaný stĺpec porovnať s hodnotou. Medzi bežné porovnávacie operátory SQL patria:
|
Operátor |
Použitie |
|
= |
Rovnosť |
|
!= |
Nerovnosť |
|
< |
Menej ako |
|
> |
Viac ako |
|
<= |
Menej alebo rovné |
|
>= |
Viac alebo rovné |
|
BETWEEN |
Testuje, či hodnota leží v danom rozsahu. |
|
IN |
Testuje, či je hodnota riadku obsiahnutá v množine zadaných hodnôt. |
|
EXISTS |
Testuje, či riadok existuje |
|
LIKE |
Testuje, či hodnota zodpovedá zadanému reťazcu |
|
IS NULL |
Testuje nulové hodnoty (NULL) |
|
IS NOT NULL |
Testuje všetky hodnoty okrem NULL |
Ak by ste chceli nájsť obľúbenú destináciu pre Aisha, mohli by ste použiť dopyt nižšie:
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
Dopyt potom vráti:
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 riadok v sade (0.03 sek) |
SQL podporuje používanie zástupných znakov, ktoré sú obzvlášť užitočné v WHERE klauzulách. Znaky percenta ( %) označujú nulu alebo viac neznámych znakov, zatiaľ čo podčiarkovníky ( _) označujú jeden neznámy znak. Tieto sú užitočné, ak chcete nájsť konkrétny záznam v tabuľke, ale nie ste si ním istí.
Napríklad, ak ste zabudli obľúbenú destináciu priateľa a vedeli ste len písmeno, ktorým začína, napríklad “m.” Názov destinácie môžete nájsť pomocou nasledujúceho dopytu:
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
Dopyt vráti:
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Maldivy | | Maurícius | +-------------+ 2 riadky v sade (0.04 sek) |
Pri práci s databázami sa môžete stretnúť so stĺpcami alebo tabuľkami s relatívne dlhými alebo ťažko čitateľnými názvami. V týchto prípadoch môžete názvy urobiť čitateľnejšími pomocou kľúčového slova AS na vytvorenie aliasu. Aliasy vytvorené pomocou AS sú platné len počas trvania dopytu, pre ktorý boli vytvorené:
|
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 | Maldivy | lyžovanie | | Ivan | Maurícius | paragliding | | Aisha | Colorado | horské lezenie | | Zane | Bora Bora | rybárčenie | +--------+-----------+-------------------+ 4 riadky v sade (0.00 sek) |
Krok 3 — Úvod do agregačných funkcií
Pri práci s dátami nechcete vždy vidieť samotné dáta. Radšej by ste mali informácie o dátach. Spustením dopytu SELECT môžete interpretovať alebo spúšťať výpočty nad vašimi dátami pomocou syntaxe SQL. Tieto sa označujú ako agregačné funkcie.
Funkcia COUNT spočíta a vráti počet riadkov, ktoré spĺňajú špecifický súbor kritérií. Napríklad, ak chcete vedieť, koľko priateľov uprednostňuje cestu na Maldivy, môžete použiť nasledujúci dopyt:
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Maldives'; |
Vrátia sa nasledujúce výsledky:
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 riadok v sade (0.06 sek) |
MIN sa používa na nájdenie najmenšej hodnoty v špecifikovanom stĺpci:
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
Dopyt vypíše:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 riadok v sade (0.02 sek) |
MAX sa používa na nájdenie najväčšej číselnej hodnoty v danom stĺpci:
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
Očakávaný výstup je:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 riadok v sade (0.03 sek) |
Obe funkcie MIN a MAX sa dajú použiť na číselné aj abecedné údaje. Pri použití na stĺpec reťazcových hodnôt funkcia MIN vráti prvú hodnotu podľa abecedy.
Funkcia MIN vráti prvú hodnotu podľa abecedy:
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
Tu je ukážka výstupu:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 riadok v sade (0.00 sek) |
Funkcia MAX vráti poslednú hodnotu podľa abecedy:
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
Výstup bude nasledovný:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 riadok v sade (0.00 sek) |
Krok 4 — Manipulácia s výstupmi dopytov
Ďalšou populárnou klauzulou, ktorá sa používa, je GROUP BY klauzula. Používa sa pri vykonávaní agregačnej funkcie nad jedným stĺpcom, ale vo vzťahu k zodpovedajúcim hodnotám v inom:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
Výstup bude:
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | lyžovanie | | 1 | paragliding | | 1 | horské lezenie | | 1 | rybárčenie | +-------------+-------------------+ 4 riadky v sade (0.04 sek) |
Na zoradenie výsledkov dopytu použite ORDER BY klauzulu. Číselné hodnoty sa predvolene zoraďujú vzostupne, zatiaľ čo textové hodnoty sa zoraďujú abecedne. Dopyt nižšie uvádza stĺpce name a birthdate , ale zoraďuje výsledky podľa birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
Výstup bude nasledovný:
|
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 riadky v sade (0.04 sek) |
Výstup je vo vzostupnom poradí. Ak ho chcete zoradiť v zostupnom poradí, ukončite dopyt slovom DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Pozrite sa na výstup:
|
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 riadky v sade (0.00 sek) |
Klauzula HAVING bola pridaná do SQL, aby poskytovala podobnú funkčnosť ako klauzula WHERE, pričom je zároveň kompatibilná s agregačnými funkciami. Rozdiel medzi týmito dvoma klauzulami je v tom, že WHERE slúži na odkazovanie na jednotlivé záznamy a HAVING odkazuje na skupinové záznamy. Z tohto dôvodu musí byť klauzula GROUP BY prítomná vždy, keď sa používa klauzula HAVING:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
Dopyt vráti výstup:
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | lyžovanie | | 1 | paragliding | | 1 | horské lezenie | | 1 | rybárčenie | +-------------+-------------------+ |
Počet COUNT je u všetkých 1, pretože žiadni dvaja priatelia nemajú radi rovnakú aktivitu.
Krok 5 — Dopytovanie nad viacerými tabuľkami
Klauzula JOIN sa môže použiť vo výsledku dopytu na spojenie riadkov z dvoch alebo viacerých tabuliek. Dosahuje to vyhľadaním súvisiaceho stĺpca medzi tabuľkami a príslušným zoradením výstupu.
SELECT príkazy, ktoré obsahujú klauzulu JOIN, sa riadia nasledujúcou syntaxou:
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Ak by ste chceli kúpiť každému zo svojich priateľov trofej za ich wins počas swimming na ich birthdays, mohli by ste vytvoriť dopyt, ktorý spojí obe tabuľky, aby vám pomohol nájsť všetky požadované informácie pomocou jediného dopytu:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
Výstup bude:
|
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 riadky v sade (0.00 sek) |
Toto je vnútorná JOIN klauzula. Je to preto, že vyberá všetky záznamy, ktoré majú zhodné hodnoty v oboch tabuľkách, a vypisuje ich do výslednej sady. Záznamy, ktoré nezodpovedajú dopytu, nie sú zahrnuté. Do našich tabuliek môžeme pridať nový riadok, ktorý nezodpovedá žiadnemu záznamu:
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Dopyt OK, 1 riadok ovplyvnený (0.01 sek) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Dopyt OK, 1 riadok ovplyvnený (0.01 sek) |
Potom znova spustite príkaz SELECT s klauzulou 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 riadky v sade (0.00 sek) |
Pretože tabuľka celebration nemá žiadny záznam pre Petra a tabuľka vacation nemá žiadny záznam pre Ellu, tieto záznamy chýbajú.
Všetky záznamy z jednej z tabuliek môžeme vrátiť pomocou vonkajšej klauzuly JOIN. Môže to byť buď LEFT JOIN alebo RIGHT JOIN. LEFT JOIN vracia všetky záznamy z ľavej tabuľky a iba zhodné záznamy z pravej tabuľky. Ľavá tabuľka v kontexte vonkajších spojení je tá, na ktorú odkazuje klauzula FROM, a pravá tabuľka je akákoľvek tabuľka uvedená za príkazom JOIN.
Spustite dopyt znova, ale použite klauzulu LEFT JOIN:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
Príkaz vráti všetky záznamy z ľavej tabuľky ( celebration) aj v prípade, že nemá zodpovedajúci záznam v pravej tabuľke. Ak v pravej tabuľke neexistuje zhodný záznam, vráti sa ako 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 riadky v sade (0.00 sek) |
Toto je 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; |
Vrátené budú všetky hodnoty z pravej tabuľky (vacation). Pretože Petrov birthdate je zaznamenaný v pravej tabuľke a nie v ľavej tabuľke, stĺpce name a wins vrátia v týchto riadkoch NULL hodnoty:
|
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 rows in set (0.01 sec) |
Môžete použiť klauzulu UNION namiesto klauzuly JOIN na dopytovanie záznamov z viacerých tabuliek. Operátor UNION sa líši od klauzuly JOIN v tom, že kombinuje výsledky dvoch príkazov SELECT do jedného stĺpca, namiesto toho, aby vypisoval výsledky z viacerých tabuliek ako jedinečné stĺpce pomocou jediného príkazu SELECT.
Tento dopyt môžete spustiť na ilustráciu:
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
Dopyt odstráni duplicitné záznamy. Toto je predvolené správanie operátora UNION:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 rows in set (0.00 sec) |
Ak chcete vrátiť všetky záznamy (vrátane duplikátov), použite operátor UNION ALL:
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Výstup:
|
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 rows in set (0.00 sec) |
Poddopyty sú ďalšou metódou na dopytovanie sa viacerých tabuliek. Poddopyty sú dopyty, ktoré sú vložené do iného dopytu (známe aj ako vnútorné alebo vnorené dopyty). Sú užitočné, keď chcete porovnať výsledky dopytu s výsledkami samostatnej agregovanej funkcie.
Použijeme príklad, v ktorom sa pokúsime zistiť, ktorý priateľ vyhral viac plaveckých turnajov ako Ella. Namiesto zisťovania, koľko zápasov Ella vyhrala, a následného spustenia ďalšieho dopytu na zistenie, kto vyhral viac zápasov, môžete oboje vypočítať pomocou jediného dopytu:
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
Dopyt vráti:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | name | wins | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 rows in set (0.06 sec) |
Ak by ste chceli vziať svojich priateľov na prekvapivú dovolenku, môžete použiť dopyt na zistenie, kto má najviac výhier, a vrátiť ich destináciu:
|
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)); |
Dopyt vráti:
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | name | destination | activity | meal | +------+-------------+----------+------+ | Zane | Bora Bora | fishing | Tofu | +------+-------------+----------+------+ 1 row in set (0.00 sec) |
Tento príkaz obsahuje poddopyt v rámci poddopytu.
Záver
Generovanie dopytov je jednou z najbežnejších úloh pri správe databáz. Existuje niekoľko nástrojov na správu databáz, ako napríklad phpMyAdmin a pgAdmin, ktoré môžete použiť na prácu s dopytmi a vizualizáciu ich výsledkov. Príkaz SELECT z príkazového riadku je však najpreferovanejšou voľbou vďaka jeho jednoduchému použitiu a vynikajúcej kontrole.
Okrem toho existuje mnoho návodov o databázach, ktoré môžete preskúmať na našom blogu:
- SQLite vs MySQL vs. PostgreSQL: Porovnanie systémov riadenia relačných databáz
- Rýchle riešenia na opravu poškodených tabuliek v MySQL: Návod
- Ako nainštalovať MySQL na Centos 7
- MySQL používateľ — Vytvorenie a udelenie oprávnení
- Nastavenie replikácie v MySQL na Ubuntu
Príjemnú prácu s počítačom!
Komentáre
Zatiaľ žiadne komentáre. Buďte prvý.