Az üzleti fenntarthatóság nehéz a megfelelő adatkezelés nélkül. Egy jól meghatározott rendszer felépítése elengedhetetlen a belső és külső műveletek kezeléséhez. Az üzleti adatokba való részletes betekintés segít megérteni a teljes munkafolyamatot és mérni a teljesítményt. Ráadásul az adatbázisok használata időt takarít meg, és lehetővé teszi az információk könnyed elérését.
Mi az az adatbázis?
Az adatbázis egy olyan szervezett rendszer, amelyet az információk biztonságos tárolására használnak. Kategorizálást kínál, és lehetővé teszi táblázatok létrehozását a hasonló típusú elemek egy csoportba történő rendezéséhez. A táblázatok lehetőséget biztosítanak az információk több sorban és oszlopban történő listázására. Ennek eredményeként javul az adatok minősége és konzisztenciája. A tárolási és könnyen hozzáférhető képességek mellett az adatbázisok jelentős szerepet játszanak a magánélet védelmében és a rendszerek biztonságossá tételében. Legyen szó ad hoc jellegűről vagy egy alkalmazásba kódolt folyamat részéről, az adatok lekérdezése az adatbázis-kezelés egyik legkritikusabb szempontja.
Egy lekérdezés a relációs DMS-ben minden olyan parancs, amelyet adatok táblából való lekérésére használnak. SELECT utasításokat szinte mindig használnak a Structured Query Language (SQL) lekérdezésekben. Számos módszer létezik az információk adatbázisból történő lekérésére. Általában a fejlesztők a parancssori opciót részesítik előnyben, mert az gyors és hatékony. Lehetővé teszi a lekérdezések zökkenőmentes elküldését.
Ebben az útmutatóban bemutatjuk a MySQL-t, és megbeszéljük, hogyan dolgozhatsz lekérdezésekkel a MySQL-ben. Kezdjük el!
Előfeltételek
Az útmutató követéséhez a következőkre lesz szükséged:
-
A legújabb verziójú Ubuntu telepítve van a rendszereden.
-
A rendszerfelhasználóknak rendelkezniük kell sudo jogosultságokkal.
-
Ha nehézségekbe ütközöl a sudo fiókod elérésével, fontold meg a MySQL root jelszó.
-
-
A MySQL be van állítva a szervereden.
1. lépés — Adatbázis létrehozása és beállítása
Mielőtt elkezdenénk és megírnánk az első SQL lekérdezésünket, létre kell hoznunk egy adatbázist, és táblákat kell hozzáadnunk. Ezután feltöltjük a táblákat mintaadatokkal. Az adatbázisokkal való munka segít megérteni az alapvető beállításokat, és önbizalmat ad a lekérdezésekkel való munkához.
A gyakorlati tapasztalat a leghatékonyabb módja a fogalmak felépítésének és az adatbázisok fontosságának megértésének. Ebben az útmutatóban végigvezetünk az adatbázisok használatán és azok jelentőségén a valós problémák megoldásában. Nézzünk meg egy forgatókönyvet, hogy megértsük, hogyan segíthetnek az adatbázisok a rekordok strukturált rendszerezésében.
Forgatókönyv: Létrehozunk egy adatbázist, ahol egy főiskolás diákokból álló csoport nyaralni megy, hogy megünnepeljék a születésnapjukat. A nyaralás előtt azt tervezik, hogy részt vesznek egy barátságos úszóversenyen. Emellett a csoport minden tagja tervez egy tennivalólistát a tevékenységekről, hogy a kirándulásuk izgalmas és élvezetes legyen.
Először nyisd meg a MySQL-t root felhasználóként:
|
1 |
$ sudo mysql |
Ezután hozz létre egy adatbázist a következő parancs futtatásával:
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Query OK, 1 row affected (0.52 sec) |
Ezután használjuk az adatbázisunkat a következő paranccsal:
|
1 |
mysql> USE vacation; |
Ezután táblákat hozunk létre az adatbázisunkban. Nevezd el az első táblát így: celebration. A táblázatunkban oszlopok lesznek a barátaink neveinek (name), az általuk megnyert versenyeknek (wins) és egy oszlop a best legjobb idejüknek (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) |
Ezután feltöltjük a táblánkat adatokkal:
|
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 |
Ezután hozzon létre egy másik táblát az adatbázisunkban, hogy tárolja a kedvenc születésnapi tevékenységeikre vonatkozó információkat. Létrehozunk egy táblát, amelynek neve vacation és a következő oszlopokkal fog rendelkezni:
|
Lista |
Részletek |
|
name: |
Tárolja az egyes barátok nevét. |
|
birthdate: |
Nyomon követi az egyes személyek születési dátumát. |
|
activity: |
Nyilvántartja a kedvenc tevékenységüket. |
|
Destination: |
Tárolja az egyes személyek kedvenc úti céljára vonatkozó információkat. |
|
meal: |
Nyomon követi az egyén által kedvelt kedvenc ételt. |
|
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) |
Töltse fel a táblát adatokkal:
|
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 |
Ezzel befejezte az adatbázis beállítását.
2. lépés — Kezdő lépések a SELECT utasításokkal
Az SQL-lekérdezések általában a következővel kezdődnek: SELECT. Ez a lekérdezésekben arra szolgál, hogy meghatározza, a tábla mely oszlopai térjenek vissza az eredményekkel. Egy lekérdezésnek mindig tartalmaznia kell a következőt is: FROM, amely a lekérdezni kívánt tábla megadására szolgál.
A lekérdezések az alábbi szintaxist követik:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
A lekérdezési szintaxist fogjuk használni a következő oszlop visszaadásához: meal oszlop a következő táblából: vacation tábla:
|
1 |
mysql> SELECT meal FROM vacation; |
A kimenetünk a következő lesz:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Fries | | Tofu | +-------+ 4 rows in set (0.00 sec) |
Több oszlopot is kiválaszthat, ha vesszővel választja el őket:
|
1 |
mysql> SELECT name, destination FROM vacation; |
Output:
|
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) |
Egy csillagot (*) is használhat, ha a tábla összes oszlopát szeretné ábrázolni:
|
1 |
mysql> SELECT * FROM celebration; |
Output:
|
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) |
Ha olyan rekordokat szeretne szűrni, amelyek megfelelnek egy meghatározott feltételnek, használja a WHERE záradékot. Azok a sorok, amelyek nem felelnek meg a megadott feltételnek, kikerülnek az eredmények közül. A WHERE záradék a következő szintaxist használja:
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
Ez egy összehasonlító operátor, amely meghatározza, hogyan kell a megadott oszlopot összehasonlítani az értékkel. A gyakori SQL összehasonlító operátorok a következők:
|
Operátor |
Használat |
|
= |
Egyenlőség |
|
!= |
Egyenlőtlenség |
|
< |
Kisebb, mint |
|
> |
Nagyobb, mint |
|
<= |
Kisebb vagy egyenlő |
|
>= |
Nagyobb vagy egyenlő |
|
BETWEEN |
Azt vizsgálja, hogy az érték a megadott tartományon belül esik-e. |
|
IN |
Azt vizsgálja, hogy egy sor értéke szerepel-e a megadott értékek halmazában. |
|
EXISTS |
Azt vizsgálja, hogy létezik-e sor |
|
LIKE |
Azt vizsgálja, hogy egy érték megegyezik-e a megadott karakterlánccal |
|
IS NULL |
Null értékeket vizsgál |
|
IS NOT NULL |
A NULL-tól eltérő összes értéket vizsgálja |
Ha meg szeretné tudni Aisha kedvenc úti célját, a következő lekérdezést használhatja:
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
The query will then return:
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 row in set (0.03 sec) |
SQL supports the use of wildcard characters, which are especially useful in WHERE clauses. Percentage signs ( %) denote zero or more unknown characters, while underscores ( _) denote a single unknown character. These are helpful if you want to find a specific entry in a table but aren’t sure about the entry.
For instance, if you had forgotten the favorite destination of a friend and only knew the letter, it starts with, for example, “m.” You can find the destination name by use of the following query:
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
The query will return:
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Maldives | | Mauritius | +-------------+ 2 rows in set (0.04 sec) |
When working with databases, you may encounter columns or tables with relatively long or difficult-to-read names. In these cases, you can make the names more readable by using the AS keyword to create an alias. Aliases created with AS are only valid for the duration of the query for which they were created:
|
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 rows in set (0.00 sec) |
Step 3 — Introduction to Aggregate Functions
Amikor adatokkal dolgozik, nem mindig magukat az adatokat szeretné látni. Ehelyett inkább az adatokról szeretne információt kapni. Egy SELECT query, you can interpret or run calculations on your data using the SQL syntax. These are referred to as aggregate functions.
A COUNT függvény megszámolja és visszaadja a megadott feltételeknek megfelelő sorok számát. Ha például meg szeretné tudni, hány barátja szeretne a Maldív-szigetekre utazni, a következő lekérdezést használhatja:
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Maldives'; |
A következő eredmények fognak visszatérni:
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 row in set (0.06 sec) |
MIN a legkisebb érték megkeresésére szolgál egy adott oszlopban:
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
A lekérdezés kimenete a következő lesz:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 row in set (0.02 sec) |
MAX a legnagyobb numerikus érték megkeresésére szolgál egy adott oszlopban:
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
A várható kimenet a következő:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 row in set (0.03 sec) |
Mind a MIN mind a MAX függvény használható numerikus és alfabetikus adatokon is. Ha karakterlánc (string) értékeket tartalmazó oszlopra alkalmazzuk, a MIN függvény az ábécérendben legelső értéket adja vissza.
A MIN függvény az ábécérendben legelső értéket adja vissza:
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
A kimenet a következő lesz:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 row in set (0.00 sec) |
A MAX függvény az ábécérendben legutolsó értéket adja vissza:
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
A kimenet a következő lesz:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 sor ebben: készlet (0.00 mp) |
4. lépés — Lekérdezési kimenetek manipulálása
Egy másik népszerű záradék, amelyet használnak, a GROUP BY záradék. Akkor használatos, ha egy aggregált függvényt hajtunk végre egy oszlopon, de egy másik oszlop egyező értékeivel összefüggésben:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
A kimenet a következő lesz:
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | skiing | | 1 | paragliding | | 1 | mountain climbing | | 1 | fishing | +-------------+-------------------+ 4 sorok ebben: készlet (0.04 mp) |
A lekérdezési eredmények rendezéséhez használja a ORDER BY záradékot. A numerikus értékek alapértelmezés szerint növekvő sorrendben, míg a szöveges értékek ábécérendben vannak rendezve. Az alábbi lekérdezés kilistázza a name és birthdate oszlopokat, de az eredményeket a következő szerint rendezi: birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
A kimenet a következő lesz:
|
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 sorok ebben: készlet (0.04 mp) |
A kimenet növekvő sorrendben van; a csökkenő sorrendbe állításhoz zárja le a lekérdezést a következő szóval: DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Tekintse meg a kimenetet:
|
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 sorok ebben: készlet (0.00 mp) |
A HAVING záradék azért került hozzáadásra az SQL-hez, hogy a WHERE záradékhoz hasonló funkcionalitást biztosítson, miközben kompatibilis az aggregált függvényekkel is. A különbség a két záradék között az, hogy a WHERE az egyes rekordokra való hivatkozásra szolgál, míg a HAVING a csoportrekordokra hivatkozik. Ebből kifolyólag a GROUP BY záradéknak jelen kell lennie minden alkalommal, amikor a HAVING záradékot használjuk:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
A lekérdezés kimenete a következő lesz:
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | skiing | | 1 | paragliding | | 1 | mountain climbing | | 1 | fishing | +-------------+-------------------+ |
A COUNT értéke mindegyiknél 1, mert nincs két olyan barát, aki ugyanazt a tevékenységet kedvelné.
5. lépés — Több tábla lekérdezése
A JOIN záradék használható a lekérdezés eredményében két vagy több tábla sorainak kombinálására. Ezt úgy éri el, hogy megkeresi a táblák közötti kapcsolódó oszlopot, és megfelelően rendezi a kimenetet.
SELECT utasítások, amelyek tartalmaznak egy JOIN záradékot, az alábbi szintaxist követik:
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Ha minden barátjának szeretne egy trófeát vásárolni a wins elért eredményeiért, miközben swimming az birthdays alkalmából, létrehozhat egy lekérdezést, amely összekapcsolja mindkét táblát, hogy egyetlen lekérdezéssel megtalálja az összes kívánt információt:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
A kimenet a következő lesz:
|
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 sor a halmazban (0.00 mp) |
Ez egy belső JOIN záradék. Ez azért van, mert kiválasztja az összes olyan rekordot, amelynek egyező értékei vannak mindkét táblában, és kiírja őket egy eredményhalmazba. A lekérdezésnek meg nem felelő rekordok nem szerepelnek az eredményben. Felvehetünk egy új sort a tábláinkba, amely nem felel meg egyik bejegyzésnek sem:
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 sor érintett (0.01 mp) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 sor érintett (0.01 mp) |
Ezután futtassa újra a SELECT utasítást a JOIN záradékkal:
|
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 sor a halmazban (0.00 mp) |
Mivel a celebration táblában nincs bejegyzés Peterhez, a vacation táblában pedig nincs bejegyzés Ellához, ezek a rekordok hiányoznak.
Az egyik tábla összes rekordját visszaadhatjuk egy külső JOIN záradék használatával. Ez lehet LEFT JOIN vagy RIGHT JOIN. A LEFT JOIN visszaadja az összes rekordot a bal oldali táblából, és csak az egyező rekordokat a jobb oldali táblából. A bal oldali tábla a külső összekapcsolások (outer join) kontextusában az, amelyre a FROM záradék hivatkozik, a jobb oldali tábla pedig bármelyik tábla, amelyre a JOIN utasítás után hivatkozunk.
Futtassa újra a lekérdezést, de használjon egy LEFT JOIN záradékot:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
A parancs visszaadja az összes rekordot a bal oldali táblából ( celebration) még akkor is, ha nincs megfelelő rekord a jobb oldali táblában. Ha nincs egyező rekord a jobb oldali táblában, akkor 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 sor a halmazban (0.00 mp) |
Ez pedig a RIGHT JOIN záradék:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration RIGHT JOIN vacation ON celebration.name=vacation.name; |
A jobb oldali tábla (vacation) összes értéke visszaadásra kerül. Mivel Peter birthdate értéke rögzítve van a jobb oldali táblában, de a bal oldali táblában a name és wins, oszlopok nem szerepelnek, ezek az oszlopok NULL értékeket fognak visszaadni azokban a sorokban:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | név | győzelmek | születési dátum | +--------+------+------------+ | 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 sor a halmazban (0.01 mp) |
Használhatja a UNION záradékot a JOIN helyett, hogy több táblából kérdezzen le rekordokat. A UNION operátor abban különbözik a JOIN záradéktól, hogy két SELECT utasítás eredményét egyetlen oszlopban egyesíti, ahelyett, hogy több tábla eredményeit egyedi oszlopokként jelenítené meg egyetlen SELECT utasítás használatával.
A szemléltetéshez futtathatja ezt a lekérdezést:
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
A lekérdezés eltávolítja a duplikált bejegyzéseket. Ez a(z) UNION operátor alapértelmezett viselkedése:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | név | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 sor a halmazban (0.00 mp) |
Az összes bejegyzés (és a duplikátumok) visszaadásához használja a UNION ALL operátort:
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Kimenet:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
+--------+ | név | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Austin | | Ivan | | Aisha | | Zane | | Peter | +--------+ 10 sor a halmazban (0.00 mp) |
Az alkérdezések egy másik módszert jelentenek több tábla lekérdezésére. Az alkérdezések olyan lekérdezések, amelyek egy másik lekérdezésbe vannak beágyazva (belső vagy beágyazott lekérdezésként is ismertek). Ezek akkor hasznosak, ha egy lekérdezés eredményeit egy különálló aggregációs függvény eredményeivel szeretné összehasonlítani.
Azt a példát fogjuk használni, hogy megkeressük, melyik barát nyert több úszóversenyt, mint Ella. Ahelyett, hogy lekérdezné, hány mérkőzést nyert Ella, majd egy másik lekérdezést futtatna, hogy megnézze, ki nyert ennél több játékot, mindkettőt kiszámíthatja egyetlen lekérdezéssel:
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
A lekérdezés a következőt adja vissza:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | név | győzelmek | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 sor a halmazban (0.06 mp) |
Ha el szeretné vinni a barátait egy meglepetés nyaralásra, egy lekérdezéssel megnézheti, kinek van a legtöbb győzelme, és lekérheti az úti célját:
|
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)); |
A lekérdezés a következőt adja vissza:
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | név | úti cél | tevékenység | étkezés | +------+-------------+----------+------+ | Zane | Bora Bora | horgászat | Tofu | +------+-------------+----------+------+ 1 sor a halmazban (0.00 mp) |
Ez az utasítás egy alkérdezést tartalmaz egy alkérdezésen belül.
Összegzés
A lekérdezések generálása az egyik leggyakoribb feladat az adatbázis-kezelésben. Számos olyan adatbázis-adminisztrációs eszköz létezik, mint a phpMyAdmin és pgAdmin, amelyeket használhat a lekérdezésekkel való munkához és az eredmények megjelenítéséhez. Azonban a parancssorból futtatott SELECT utasítás a leginkább preferált választás az egyszerű használata és a kiváló irányíthatósága miatt.
Ezenkívül számos adatbázisokkal kapcsolatos útmutatót fedezhet fel a blogunkon:
- SQLite vs MySQL vs. PostgreSQL: Relációs adatbázis-kezelő rendszerek összehasonlítása
- Gyors megoldások a sérült táblák javítására MySQL-ben: Útmutató
- Hogyan telepítsük a MySQL-t Centos 7-re
- MySQL felhasználó — Jogosultságok létrehozása és megadása
- Replikáció beállítása MySQL-ben Ubuntu-n
Kellemes számítógéphasználatot!
Hozzászólások
Még nincsenek hozzászólások. Legyen Ön az első.