SQL és NoSQL összehasonlítása

A NoSQL és az SQL adatbázisok közötti választás kulcsfontosságú döntés, amely az alkalmazás skálázhatóságát, teljesítményét és fejlesztési rugalmasságát befolyásolja. Nézzük meg részletesen a különbségeket, és vezessünk végig konkrét példákon!

1. Mi az SQL és a NoSQL?

SQL (Structured Query Language) adatbázisok

Az SQL-adatbázisok (Relációs Adatbázis Kezelő Rendszerek – RDBMS) strukturált adatok tárolására szolgálnak, amelyek előre meghatározott séma szerint szerveződnek táblázatokba.

Jellemzők:

Adatok táblázatos formában vannak tárolva sorokkal és oszlopokkal.
Fix séma: Az adatok struktúrája előre meghatározott és fix.
Relációk: Az adatok összekapcsolhatók más táblák adataival (idegen kulcsok).
Tranzakciókezelés: ACID (Atomicity, Consistency, Isolation, Durability) garantált.

📌 Példa SQL-adatbázisra:
Egy webshop esetén egy tipikus SQL-sémában lehet egy Customers (Vásárlók) tábla:

CustomerID	Name	Email	Age
1	Kovács Béla	bela@example.com	30
2	Nagy Anna	anna@example.com	25

NoSQL (Not Only SQL) adatbázisok

A NoSQL-adatbázisok strukturálatlan vagy félig strukturált adatokat tárolnak, és nem követelnek meg előre meghatározott sémát.

Jellemzők:

Rugalmas séma: Az adatok változó formában tárolhatók.
Nagy skálázhatóság: Könnyen méretezhető horizontálisan.
Nincs reláció: Az adatok gyakran egy dokumentumban vagy kulcs-érték párban tárolódnak.
BASE-modell: Nem garantálja az ACID-tranzakciókat, de végül konzisztens.

📌 Példa NoSQL-adatbázisra (Dokumentumalapú, pl. MongoDB)
Egy webshopban az ügyfelek JSON formátumban így tárolhatók:

---json

{
  "CustomerID": 1,
  "Name": "Kovács Béla",
  "Email": "bela@example.com",
  "Orders": [
    {"OrderID": 101, "Total": 5000},
    {"OrderID": 102, "Total": 15000}
  ]
}

2. Főbb különbségek az SQL és NoSQL között

Kategória	SQL	NoSQL
Adatmodell	Táblázatos, sorok és oszlopok	Kulcs-érték, dokumentum, gráf vagy oszlopalapú
Séma	Fix séma, előre definiált oszlopok	Rugalmas séma, különböző struktúrák lehetnek
Skálázhatóság	Vertikális (nagyobb szerverek)	Horizontális (több szerver, sharding)
Tranzakciók	ACID (Adatintegritás garantált)	BASE (Végső konzisztencia)
Lekérdezések	SQL (pl. SELECT, JOIN)	API vagy saját lekérdezőnyelv (pl. MongoDB Query Language)
Teljesítmény	Lassabb nagy mennyiségű olvasásnál	Gyorsabb írás- és olvasásintenzív feladatoknál
Legjobb felhasználási módok	Banki rendszerek, CRM, ERP	Nagy adatbázisok, IoT, közösségi média, Big Data

3. Részletes példák az SQL és NoSQL működésére

Példa 1: Adatok beszúrása

📌 SQL (MySQL):

---sql

INSERT INTO Customers (CustomerID, Name, Email, Age)
VALUES (1, 'Kovács Béla', 'bela@example.com', 30);

📌 NoSQL (MongoDB – JSON formátumban):

--- json

db.customers.insertOne({
  "CustomerID": 1,
  "Name": "Kovács Béla",
  "Email": "bela@example.com",
  "Age": 30
})

Példa 2: Adatok lekérdezése

📌 SQL (MySQL):

---sql

SELECT * FROM Customers WHERE Age > 25;

📌 NoSQL (MongoDB):

---json

db.customers.find({ "Age": { "$gt": 25 } })

Példa 3: Relációs lekérdezések vs. beágyazott adatok

📌 SQL (MySQL) – JOIN használata a rendelések lekérdezésére

---sql

SELECT Customers.Name, Orders.OrderID, Orders.Total
FROM Customers
JOIN Orders ON Customers.CustomerID = Orders.CustomerID;

📌 NoSQL (MongoDB) – Beágyazott dokumentumokkal

---json

db.customers.find(
  { "CustomerID": 1 },
  { "Orders": 1 }
)

Itt az Orders már eleve az ügyfél dokumentumán belül van, ezért nincs szükség JOIN-ra.

4. Mikor érdemes SQL-t és mikor NoSQL-t használni?

Mikor válassz SQL-t?

✅ Ha erős adatintegritásra van szükség (pl. bankok, vállalati rendszerek).
✅ Ha bonyolult relációk vannak az adatok között.
✅ Ha struktúrált adatokat kell kezelni és az ACID-tranzakciók fontosak.

Mikor válassz NoSQL-t?

✅ Ha nagy mennyiségű adatra és gyors olvasási-írási műveletekre van szükség (pl. közösségi média).
✅ Ha strukturálatlan vagy változó adatokat kell kezelni (pl. JSON, XML).
✅ Ha horizontálisan skálázható rendszer kell (pl. Big Data, IoT).

5. Táblázatos Összegzés: SQL vs. NoSQL

Jellemző	SQL	NoSQL
Adatmodell	Táblázatos	Dokumentum, kulcs-érték, gráf, oszlopalapú
Tranzakciókezelés	ACID	BASE (Eventually Consistent)
Séma	Fix séma	Dinamikus séma
Relációk	Támogatott (JOIN)	Nem támogatott vagy alternatív megoldások
Skálázhatóság	Vertikális (nagyobb szerverek)	Horizontális (sharding, replikáció)
Felhasználás	Pénzügy, vállalati rendszerek	Közösségi média, IoT, Big Data
Teljesítmény	Jobb komplex lekérdezéseknél	Jobb írás- és olvasásintenzív feladatoknál

Összegzés

SQL kiválóan alkalmas strukturált adatok és üzleti alkalmazások kezelésére.
NoSQL akkor jó választás, ha nagy skálázhatóságra és rugalmas adatszerkezetre van szükség.

SQL specializáció és NoSQL

1. SQL és NoSQL XML/JSON támogatása

📌 SQL adatbázisok XML és JSON támogatással

Az újabb SQL adatbázisok már fél-strukturált adatokat is képesek kezelni speciális adattípusok segítségével, például:

XML típusok és lekérdezések:

Oracle XML DB: XMLType, XMLQuery(), XMLTable(), XQuery()
SQL Server: FOR XML, OPENXML()
PostgreSQL: xml típus

JSON típusok és lekérdezések:
- PostgreSQL: json, jsonb (bináris JSON)
- MySQL: JSON adattípus
- SQL Server: FOR JSON, OPENJSON()
- Oracle: JSON_OBJECT(), JSON_TABLE()

Az SQL adatbázisok így már nemcsak táblázatos formában, hanem hierarchikus, beágyazott adatokkal is tudnak dolgozni.

📌 NoSQL adatbázisok XML és JSON kezelésre

A NoSQL rendszerek alapvetően fél-strukturált adatokra lettek tervezve, és már eleve natívan támogatják ezeket:

Dokumentumalapú adatbázisok (MongoDB, CouchDB, Firebase)
- JSON-alapú tárolás, egyszerű beágyazás, rugalmas szerkezet
Gráf-adatbázisok (Neo4j, ArangoDB)
- XML/JSON formátumok is könnyen kezelhetők gráfstruktúrában
Oszlop-alapú adatbázisok (Cassandra, HBase)
- JSON-bejegyzések egyes oszlopokban is tárolhatók
XML-natív adatbázisok (BaseX, eXistDB, MarkLogic)
- XML dokumentumokat natívan tárolnak és dolgoznak fel

2. Részletes összehasonlítás: SQL vs. NoSQL XML/JSON támogatással

Jellemző	SQL (XML/JSON támogatással)	NoSQL (natív XML/JSON támogatás)
Adatszerkezet	Táblázatos + XML/JSON típusok (pl. `CLOB`, `JSON`, `XMLType`)	Dokumentumalapú (JSON/XML natívan)
Adatlekérdezés	SQL + XML/JSON-specifikus kiegészítések (`XMLQuery()`, `JSON_TABLE()`)	JSON-alapú API-k, NoSQL natív query nyelvek
Adatintegritás	ACID (tranzakciókezelés, adatkonzisztencia)	BASE (végső konzisztencia, gyors elérés)
Séma rugalmassága	Fix sémával, de XML/JSON támogatás miatt lazább	Teljesen rugalmas séma, nincs előre meghatározott szerkezet
Teljesítmény	Lassabb nagy JSON/XML objektumokkal (indexelés és keresés bonyolultabb)	Gyors JSON/XML feldolgozás (nincs átalakítás, natívan kezeli)
Indexelés és keresés	Korlátozott indexelés XML/JSON oszlopok esetén (pl. Oracle JSON_INDEX)	Jobb indexelés és gyorsabb keresés JSON/XML dokumentumokban
Kapcsolatok és relációk	Jobb relációkezelés (SQL JOIN, idegen kulcsok)	Nincs vagy minimális relációs támogatás
Tranzakciók és adatbiztonság	Erős ACID-tranzakciókezelés	Gyors, de nincs erős ACID támogatás
Skálázhatóság	Vertikális skálázás (nagyobb szerverek)	Horizontális skálázás (sharding, replikáció)

3. Gyakorlati példák SQL és NoSQL adatbázisokban

📌 Példa 1: JSON kezelés SQL és NoSQL rendszerekben

SQL adatbázisban (PostgreSQL JSON támogatás):

---sql

SELECT jsonb_pretty(data)
FROM customers
WHERE data->>'CustomerID' = '1';

PostgreSQL jsonb típusát használja a hatékony JSON keresésre.
Hátrány: Nem natív JSON-kezelés, némi teljesítményveszteség.

NoSQL adatbázisban (MongoDB lekérdezés JSON-ben):

---json

db.customers.find({ "CustomerID": 1 })

MongoDB natív JSON struktúrával dolgozik, gyorsabb keresést biztosít.

📌 Példa 2: XML kezelés SQL és NoSQL rendszerekben

SQL adatbázisban (Oracle XML kezelés):

---sql

SELECT EXTRACTVALUE(xml_data, '/Customer/Name')
FROM customers
WHERE XMLExists('/Customer[CustomerID="1"]' PASSING xml_data);

Hátrány: XMLQuery bonyolultabb, nagyobb erőforrás-igény.

NoSQL adatbázisban (BaseX XML kezelés):

--- xquery

for $x in doc("customers.xml")//Customer[CustomerID="1"]
return $x/Name

Előny: Egyszerűbb és gyorsabb XML keresés NoSQL-ben.

4. Összegzés: SQL vagy NoSQL XML/JSON kezelésre?

📌 Mikor válassz SQL-t XML/JSON támogatással?

✅ Erős adatintegritás kell (pl. banki, pénzügyi rendszerek).
✅ SQL és relációs lekérdezések mellett szeretnéd használni XML/JSON-t.
✅ Tranzakciókezelés fontos.

📌 Mikor válassz NoSQL-t XML/JSON kezelésre?

✅ Nagy mennyiségű XML/JSON adat esetén (pl. Big Data, IoT, közösségi média).
✅ Gyors keresés és horizontális skálázhatóság szükséges.
✅ Teljes rugalmasság kell a séma nélkül.

5. Végső összehasonlító táblázat

Jellemző	SQL XML/JSON támogatással	NoSQL natív XML/JSON
Relációk	✔ Erős támogatás	✖ Nincs vagy minimális
ACID	✔ Teljes támogatás	✖ Gyengébb (BASE)
Séma	✔ Részben rugalmas	✔ Teljesen rugalmas
Teljesítmény	❌ Lassabb nagy JSON/XML struktúráknál	✔ Gyors JSON/XML feldolgozás
Skálázhatóság	❌ Korlátozott (vertikális)	✔ Kiváló (horizontális)

👉 Ha strukturált relációs adatokat kell kezelned, SQL a jobb.
👉 Ha nagy mennyiségű JSON/XML adattal dolgozol, NoSQL jobb választás.

Tesztelési lehetőség NoSQL próbára

Ha szeretnéd gyakorlatban is kipróbálni a NoSQL működését, több ingyenes és egyszerű mód is rendelkezésre áll. Az alábbiakban bemutatok néhány lehetőséget, attól függően, hogy milyen típusú NoSQL adatbázist szeretnél tesztelni.

1. Online Ingyenes NoSQL Tesztkörnyezetek (Telepítés Nélkül)

Ha nem szeretnél semmit telepíteni, akkor az alábbi böngészőben futtatható online eszközök tökéletesek lehetnek:

Adatbázis	Link	Leírás
MongoDB (JSON-alapú)	MongoDB Playground	Interaktív online MongoDB tesztkörnyezet. JSON dokumentumokat lehet benne kezelni, lekérdezni.
CouchDB (JSON-alapú, REST API)	IBM Cloud CouchDB	Ingyenes regisztráció után használható. REST API-val tesztelhető.
Firebase Realtime Database (JSON-alapú)	Firebase Console	Ingyenes Firebase adatbázis kezelése Google fiókkal.
Redis (kulcs-érték alapú)	Redis Labs Try Redis	Online interaktív Redis környezet CLI-alapú felülettel.

Ha MongoDB-t szeretnél kipróbálni telepítés nélkül, akkor a MongoDB Playground ajánlott, mert egyszerű és azonnal használható.

2. NoSQL Telepítése Saját Gépeden

Ha hosszabb távon kísérleteznél, érdemes telepíteni egy NoSQL adatbázist.

📌 MongoDB telepítése (JSON-alapú NoSQL)

A MongoDB az egyik legnépszerűbb NoSQL adatbázis, és könnyen telepíthető.

Telepítési lépések:

Letöltés: MongoDB Community Server
Telepítés: Windows/macOS/Linux esetén az egyszerű telepítővel.
Indítás:
- Parancssorban: mongod (MongoDB szerver indítása)
- mongo (MongoDB shell elindítása)

Adatbázis létrehozása és tesztelése:

---json

use testDB
db.users.insertOne({"name": "Kovács Béla", "age": 30})
db.users.find()

🔹 Ha nem akarsz telepíteni, használhatod a MongoDB Atlas-t (mongodb.com/cloud/atlas), ahol ingyenes felhő alapú adatbázist kapsz.

📌 Redis telepítése (Kulcs-Érték NoSQL)

Letöltés: Redis.io letöltés
Telepítés Windows/Linux/macOS rendszerre
Indítás:
```
---sh

redis-server
```

Tesztelés:

---sh

redis-cli
SET name "Kovács Béla"
GET name

🔹 Redis szupergyors, és remek választás, ha gyors kereséseket szeretnél végezni.

📌 Cassandra telepítése (Oszlop-alapú NoSQL)

A Cassandra a Big Data és elosztott rendszerek egyik legnépszerűbb NoSQL adatbázisa.
Telepítési lépések:

Letöltés: Apache Cassandra
Indítás:
```
---sh

cassandra -f
```

Tesztelés (CQL parancsokkal):

---sql

CREATE KEYSPACE test WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1};
USE test;
CREATE TABLE users (id UUID PRIMARY KEY, name text);

🔹 Cassandra nagy skálázhatóságot biztosít, ezért elosztott rendszerekben kiváló.

3. Felhőalapú NoSQL Szolgáltatások

Ha nem akarsz semmit telepíteni, de szeretnéd éles környezetben kipróbálni a NoSQL-t, akkor érdemes a felhőmegoldásokat használni:

Adatbázis	Platform	Link
MongoDB Atlas	AWS / Azure / GCP	MongoDB Atlas
Google Firestore	Google Cloud	Firestore
Amazon DynamoDB	AWS	DynamoDB
Azure Cosmos DB	Microsoft Azure	Cosmos DB

🔹 Előnyök:

Ingyenes csomagokkal tesztelhetők.
Könnyű skálázás és valós környezetben kipróbálható NoSQL.

4. NoSQL Működésének Kipróbálása Kóddal (Python, Node.js)

Ha már telepítettél egy NoSQL adatbázist, akkor Python vagy JavaScript (Node.js) segítségével is kipróbálhatod.

📌 Példa MongoDB használatára Pythonban

--- python

from pymongo import MongoClient

# Csatlakozás az adatbázishoz
client = MongoClient("mongodb://localhost:27017/")
db = client["testDB"]
collection = db["users"]

# Adat beszúrása
collection.insert_one({"name": "Kovács Béla", "age": 30})

# Adat lekérdezése
for user in collection.find():
    print(user)

🔹 Telepítéshez:

---sh

pip install pymongo

Ezután már Pythonból is dolgozhatsz NoSQL adatbázisokkal! 🚀

Összegzés

Ha csak gyorsan ki akarod próbálni:

MongoDB Playground vagy Try Redis böngészőben.

Ha saját gépen akarod használni:

MongoDB vagy Redis könnyen telepíthető.
Cassandra és Firebase is érdekes lehet.

Ha felhőben próbálnád ki:

MongoDB Atlas és Google Firestore ingyenes csomagokkal.

🔹 Kezdőknek ajánlott MongoDB, mert JSON-alapú, könnyen tanulható, és sok ingyenes eszköz áll rendelkezésre!

MongoDB alapfogalmak / MongoDB Logikai felépítése

Egy MongoDB-alapú adatbázis rendszer legfelső rétege az ún. klaszter, ebbe szervezzük a szervereket. Mi klaszterekkel ebben a tárgyban nem foglalkozunk, azok a skálázás eszközei. A második szint a szerver szintje (a mongod processz), ami alatt az adatbázis foglal helyet. Egy szerver/klaszter több adatbázist tárolhat. Az adatbázisok pedig gyűjteményekből (collection) épülnek fel. Ha a relációs adatbázisokkal meg akarjuk feleltetni, akkor a gyűjtemények a táblák megfelelői, ezen belül a sorok/rekordok pedig a gyűjteményben tárolt dokumentumok lesznek.