Hogyan használd a Sequelize-t Node.js-sel és MySQL-lel
A szerző az Open Internet/Free Speech Fundot választotta, hogy részesüljön adományban a Write for Donations program keretében.
Bevezetés
A Sequelize egy Node.js-alapú objektum-relációs leképező (ORM), amely megkönnyíti a MySQL, MariaDB, SQLite, PostgreSQL adatbázisok és mások kezelését. Egy objektum-relációs leképező olyan feladatokat végez, mint az adatbázis rekordok kezelése az adatok objektumokként történő ábrázolásával. A Sequelize erőteljes migrációs mechanizmussal rendelkezik, amely lehetővé teszi a meglévő adatbázis-sémák új verziókra történő átalakítását. Összességében a Sequelize kiváló támogatást nyújt az adatbázis szinkronizációhoz, eager loadinghoz, kapcsolatokhoz, tranzakciókhoz és adatbázis-migrációkhoz, miközben csökkenti a fejlesztési időt és megakadályozza az SQL-injekciókat.
Ebben a bemutatóban telepíteni és konfigurálni fogod a Sequelize-t MySQL-lel a helyi fejlesztői környezetedben. Ezután a Sequelize segítségével létrehozol adatbázisokat és modelleket, valamint végrehajtod az insert, select és delete műveleteket. Ezt követően létrehozod a Sequelize asszociációkat egy-egy, egy-több és több-több kapcsolatokat kezelve. Végül létrehozol Sequelize nyers lekérdezéseket tömb- és objektum-helyettesítésekhez. A bemutató ezen alapok mellett a biztonságos adatbázis-konfigurációt környezeti változók használatával, a séma változtatások biztonságos kezelését migrációkon keresztül, valamint a hibakeresés és teljesítmény optimalizálás legjobb gyakorlatait is tárgyalja.
Telepítse frontend alkalmazásait a GitHubról a Linux-Console.net Alkalmazásplatform segítségével. Hagyd, hogy a Linux-Console.net az alkalmazásod skálázására koncentráljon.
Főbb tanulságok:
- A Sequelize egyszerű módot biztosít a MySQL-lel való interakcióra modellek használatával a nyers SQL helyett, így az adatbázisműveletek egyszerűbbé és átláthatóbbá válnak.
- Az adatbázis-hitelesítő adatok környezeti változókban történő tárolása biztonságban tartja az érzékeny információkat, és kizárja őket a verziókezelésből.
- A sémaváltozásokhoz való migrációk használata biztonságosabb, mint a
sequelize.sync()-ra támaszkodni, különösen éles környezetben. - A Sequelize megkönnyíti az egy-az-egyhez, egy-a-többhöz és több-a-többhöz kapcsolatok meghatározását a modellek között.
- A nyers SQL lekérdezések továbbra is használhatók, amikor nagyobb irányításra vagy jobb teljesítményre van szükség bonyolult adatbázis-műveletek esetén.
- A leggyakoribb Sequelize-problémák, például a kapcsolódási hibák vagy a migrációs hibák, megoldhatók a környezeti változók ellenőrzésével, a naplók áttekintésével és MySQL-eszközök, például a
EXPLAINés aSHOW PROCESSLISThasználatával. - A teljesítmény javítható a lekérdezések optimalizálásával, megfelelő indexek hozzáadásával, a kapcsolati poolok hangolásával és a gyakran használt adatok gyorsítótárazásával.
- A migrációk tesztelése, a hibakezelés hozzáadása és az adatbázis teljesítményének figyelése segít abban, hogy a Sequelize alkalmazások megbízhatóak és gyártásra kész állapotban maradjanak.
Előfeltételek
A bemutató befejezéséhez szükséged lesz:
- Egy fejlesztői környezet, amely Node.js-t futtat. Ennek beállításához kövesse az útmutatót: Hogyan telepítsük a Node.js-t és hozzunk létre egy helyi fejlesztői környezetet az operációs rendszeréhez.
- A MySQL telepítve van a munkakörnyezetében. Kövesse a MySQL telepítéséről szóló útmutatót az Ön környezetéhez, beleértve a felhasználó létrehozására vonatkozó lépéseket is.
- Ismeretek a JavaScript és a MySQL lekérdezések terén, amelyeket a How To Code in JavaScript sorozattal és az An Introduction to Queries in MySQL oktatóanyaggal fejleszthetsz.
- Az alapvető relációs adatbázis-koncepciók megértése, amelyet a „Relációs adatbázisok megértése” című útmutatóban találhat meg.
Ezt a bemutatót a Node.js v24.11.1-es verzióján és a npm 11.6.2-es verzióján tesztelték.
A Sequelize telepítése és konfigurálása
Ebben a lépésben telepíted a Sequelize-t, és létrehozod a kapcsolatot a MySQL adatbázisoddal. Ehhez először létrehozol egy Node.js alkalmazást. Ezután telepíted a Sequelize-t, konfigurálod a MySQL adatbázist, és fejlesztesz egy egyszerű alkalmazást.
A Sequelize telepítése
Kezdjük azzal, hogy létrehozunk egy projektmappát. Ebben a példában használhatod a hello-world mappát. Miután a mappa létrehozásra került, navigálj a mappába a terminál segítségével:
mkdir hello-world
cd hello-worldEzután hozz létre egy minta Node.js alkalmazást a következő parancs használatával:
npm initEzután arra fogják kérni, hogy válaszolj néhány beállítási kérdésre. A konfigurációdhoz használd a következő kimenetet. Nyomd meg az ENTER billentyűt a megjelenített alapértelmezett érték használatához, és győződj meg róla, hogy a fő belépési pontot server.js-re állítod. Ez egy könnyen karbantartható projektstruktúrát hoz létre.
A kimenet a következőképpen fog kinézni, és feltölti a package.json fájlt:
{
"name": "hello-world",
"version": "1.0.0",
"description": "",
"main": "server.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}Ezután hozz létre egy üres server.js fájlt a projekt mappájában:
touch server.jsA korábbi lépések követése után a végső mappaszerkezet így fog kinézni:
hello-world/
├─ package.json
├─ server.jsMost a következő parancs segítségével telepítheted a Sequelize-t:
npm i sequelizeEzek után a package.json fájl most így néz ki:
{
"name": "hello-world",
"version": "1.0.0",
"description": "",
"main": "server.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"start": "node server.js"
},
"author": "",
"license": "ISC",
"dependencies": {
"sequelize": "^6.37.7"
}
}A dependencies szakaszban most már látható egy Sequelize-függőség.
Beállította a projektet és telepítette a Sequelize-t. Ezután létre fog hozni egy példabázist, amelyhez csatlakozni fog.
Mintaadatbázis létrehozása
A követelmények részeként telepítetted és beállítottad a MySQL-t, ami magában foglalta egy felhasználó létrehozását is. Most létre fogsz hozni egy üres adatbázist.
Ehhez először be kell jelentkezned a MySQL példányodba. Ha távolról futtatod, használhatod a kedvenc eszközödet. Ha helyileg futó MySQL példányt használsz, a következő parancsot használhatod, a your_username helyére a MySQL felhasználónevedet írva:
mysql -u your_username -pA -u a felhasználónév, és a -p opciót akkor adjuk meg, ha a fiók jelszóval védett.
A MySQL szerver kéri az adatbázis jelszavát. Írd be a jelszavad, majd nyomd meg az ENTER billentyűt.
Miután bejelentkeztél, hozz létre egy hello_world_db nevű adatbázist a következő parancs használatával:
CREATE DATABASE hello_world_db;Annak ellenőrzésére, hogy sikeresen létrehoztad-e az adatbázist, használhatod ezt a parancsot:
SHOW DATABASES;A kimeneted hasonló lesz ehhez:
+--------------------+
| Database |
+--------------------+
| hello_world_db |
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+Miután létrehoztad a mintaadatbázist, bontsd a kapcsolatot a MySQL szerverrel:
mysql> QUITMost telepítened kell egy kézi illesztőprogramot a választott adatbázisodhoz. Mivel a Sequelize csak ORM funkciókat biztosít, nincs beépített adatbázis-illesztőprogramja. Ezért az igényeid szerint kell telepítened a megfelelő illesztőprogramot. Ehhez lépj a projekt könyvtárába a terminál segítségével, és telepítsd a MySQL illesztőprogramot a projekthez az alábbi parancs futtatásával:
npm install --save mysql2Ebben az esetben a MySQL-hez való illesztőprogramot használja.
Megjegyzés: Mivel ez a bemutató MySQL-t használ adatbázisként, ehhez egy meghajtót kell használnia. Az adatbázistól függően a meghajtót manuálisan is telepítheti az alábbi módon:
npm install --save pg pg-hstore # Postgresnpm install --save mysql2npm install --save mariadbnpm install --save sqlite3npm install --save tedious # Microsoft SQL Server
Most, hogy van egy mintaadatbázisod, létrehozhatod az első Sequelize alkalmazásodat adatbázis-kapcsolattal.
Kapcsolódás a MySQL adatbázishoz
Ebben a részben a Node.js alkalmazást fogjuk a MySQL adatbázishoz csatlakoztatni a Sequelize használatával.
A adatbázishoz való csatlakozáshoz nyisd meg szerkesztésre a server.js fájlt a nano segítségével, vagy a kedvenc kódszerkesztőddel:
nano server.jsItt a alkalmazásodban egy adatbázis-kapcsolatot fogsz létrehozni egy Sequelize példány használatával. A new Sequelize() metódusban add át a MySQL szerver paramétereit és az adatbázis-hitelesítő adatokat a következőképpen, helyettesítve a DATABASE_USERNAME és DATABASE_PASSWORD értékeket a MySQL felhasználód hitelesítő adataival:
const Sequelize = require("sequelize");
const sequelize = new Sequelize(
'hello_world_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);host az a hely, ahol a MySQL szerver található, ezért meg kell adnod egy szerver URL-t vagy egy IP-címet. Ha helyileg telepített MySQL szervert használsz, a DATABASE_HOST-ot a localhost vagy a 127.0.0.1 értékre cserélheted.
Hasonlóképpen, ha távoli szervert használ, győződjön meg róla, hogy a adatbázis-kapcsolati értékeket a megfelelő távoli szerver adataira cseréli.
Megjegyzés: Ha más adatbázis-szerver szoftvert használ, a dialektus paramétert ennek megfelelően cserélheti.
Ezután hívd meg a promise-alapú authenticate() metódust, hogy létrehozz egy adatbázis-kapcsolatot az alkalmazáshoz. Ehhez add hozzá a következő kódrészletet a server.js fájlodhoz:
...
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});A authenticate() metódust az adatbázishoz való kapcsolódásra használjuk, és ellenőrzi, hogy a megadott hitelesítő adatok helyesek-e. Itt az adatbázis-kapcsolat alapértelmezés szerint nyitva van, és ugyanaz a kapcsolat használható minden lekérdezéshez. Ha be szeretnéd zárni a kapcsolatot, hívd meg a sequelize.close() metódust a authenticate() hívása után. Ha többet szeretnél megtudni a Sequelize-ról, kérlek, nézd meg a kezdő útmutatójukat.
A Sequelize által biztosított módszerek többsége aszinkron. Ez azt jelenti, hogy az alkalmazásodban futtathatsz más folyamatokat, miközben egy aszinkron kódrész éppen végrehajtás alatt áll. Továbbá, az aszinkron kódrész sikeres végrehajtása után egy promise-t ad vissza, amely az adott folyamat végén visszaadott érték. Ezért az aszinkron kódrészben használhatod a then(), catch() és finally() metódusokat a feldolgozott adatok visszaadására.
Ekkor a server.js fájl a következőképpen fog kinézni:
const Sequelize = require("sequelize");
const sequelize = new Sequelize(
'hello_world_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});Mentse el és zárja be a fájlját.
A projekt könyvtárában futtassa a server.js alkalmazást a következő parancs kiadásával:
node server.jsA kimeneted így fog kinézni:
Connection has been established successfully!A adatbázis-kapcsolatot sikeresen létrehozta.
Ebben a lépésben telepítette a Sequelize-t, létrehozott egy mintaadatbázist, és a Sequelize segítségével csatlakozott az adatbázishoz. Ezután a Sequelize modellekkel fog dolgozni.
Adatbázis tábla létrehozása Sequelize segítségével
Most, hogy létrehoztál egy minta MySQL adatbázist, a Sequelize segítségével létrehozhatsz egy táblát, és feltöltheted adatokka. A Sequelize-ben az adatbázis táblákat modelleknek nevezik. Egy modell egy absztrakció, amely az adatbázis egy tábláját képviseli. A modellek számos dolgot határoznak meg a Sequelize számára, például a tábla nevét, az oszlopok részleteit és az adatok típusát. Ebben a lépésben egy Sequelize modellt fogsz létrehozni a könyv adatokhoz.
Először hozz létre egy új fájlt book.model.js néven a projekt könyvtárában:
nano book.model.jsHasonlóan az előző lépéshez, add hozzá a Sequelize kódot az adatbázis inicializálásához, egy új DataTypes importtal a fájl tetején:
const { Sequelize, DataTypes } = require("sequelize");A Sequelize számos beépített adattípust tartalmaz. Ezekhez az adattípusokhoz úgy férhetsz hozzá, hogy importálod a DataTypes-t. Ez a bemutató néhány gyakran használt adattípust említ, például a STRING, INTEGER és DATEONLY típusokat. Ha többet szeretnél megtudni a támogatott adattípusokról, a hivatalos Sequelize dokumentációt érdemes tanulmányozni.
Ezután illessze be azokat a sorokat, amelyeket korábban a MySQL adatbázishoz való kapcsolódáshoz használt, a MySQL hitelesítő adatait megfelelően frissítve:
...
const sequelize = new Sequelize(
'hello_world_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});Ezután létrehozol egy books nevű modellt, amely tartalmazza a title, author, release_date és subject ID mezőket. Ehhez használd a sequelize.define() módszert az alábbi módon:
...
const Book = sequelize.define("books", {
title: {
type: DataTypes.STRING,
allowNull: false
},
author: {
type: DataTypes.STRING,
allowNull: false
},
release_date: {
type: DataTypes.DATEONLY,
},
subject: {
type: DataTypes.INTEGER,
}
});A sequelize.define() metódus egy új modellt definiál, amely a adatbázisban lévő táblát képvisel. Ez a kódrészlet létrehoz egy books nevű táblát, és a könyvrekordokat a title, author, release_date és subject szerint tárolja.
Ebben a kódban az allowNull azt jelzi, hogy a modell oszlopának értéke nem lehet null. Hasonlóképpen, ha be szeretnél állítani egy ilyen értéket, használhatod a defaultValue: "value" kifejezést.
Ezután hozzáadod a book modellt az adatbázisodhoz. Ehhez a sync() metódust az alábbi módon fogod használni:
...
sequelize.sync().then(() => {
console.log('Book table created successfully!');
}).catch((error) => {
console.error('Unable to create table : ', error);
});A sync() metódusban azt kéred a Sequelize-től, hogy végezzen el néhány műveletet az adatbázisban. Ezzel a hívással a Sequelize automatikusan végrehajt egy SQL lekérdezést az adatbázisban, létrehoz egy táblát, és kiírja a Book table created successfully! üzenetet.
Ahogy említettük, a sync() metódus egy ígéret-alapú (promise-based) metódus, ami azt jelenti, hogy hibakezelést is tud végezni. Ebben a kódrészletben ellenőrizni fogod, hogy a tábla sikeresen létrejött-e. Ha nem, a catch metóduson keresztül visszaad egy hibát és kiírja a kimenetre.
Megjegyzés: A modell szinkronizációját a force paraméterek átadásával kezelheted, hogy új táblát hozz létre, ha az még nem létezik, vagy használj egy meglévőt. Íme néhány példa, amelyek hasznosak lehetnek a Sequelize használata során:
model.sync(): Ez létrehozza a táblát, ha az még nem létezik.model.sync({ force: true }): Ez létrehozza a táblát, és ha már létezik ugyanilyen tábla, előbb törli azt.
A végső kód így fog kinézni:
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'hello_world_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});
const Book = sequelize.define("books", {
title: {
type: DataTypes.STRING,
allowNull: false
},
author: {
type: DataTypes.STRING,
allowNull: false
},
release_date: {
type: DataTypes.DATEONLY,
},
subject: {
type: DataTypes.INTEGER,
}
});
sequelize.sync().then(() => {
console.log('Book table created successfully!');
}).catch((error) => {
console.error('Unable to create table : ', error);
});Mentse el és zárja be a fájlját.
Futtassa az alkalmazást a következő parancs használatával:
node book.model.jsA parancssorban a következő kimenetet fogja kapni:
Executing (default): SELECT 1+1 AS result
Executing (default): CREATE TABLE IF NOT EXISTS `books` (`id` INTEGER NOT NULL auto_increment , `title` VARCHAR(255) NOT NULL, `author` VARCHAR(255) NOT NULL, `release_date` DATE, `subject` INTEGER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB;
Connection has been established successfully.
Executing (default): SHOW INDEX FROM `books`
Book table created successfully!A kimenetben látni fogod, hogy a visszatérési napló tartalmazza az üzenetet: Book table created successfully!. Ezt ellenőrizheted az adatbázisodban is, hogy lásd az új books táblát a hello_world_db adatbázisban.
Az új tábla létrehozásának ellenőrzéséhez jelentkezzen be a MySQL példányába:
mysql -u YOUR_USERNAME -pMiután megadta a jelszavát, váltson át a minta adatbázisra:
USE hello_world_db;Ezután futtasd a parancsot a táblák megjelenítéséhez:
SHOW TABLES;A kimeneted hasonló lesz ehhez:
+---------------------------+
| Tables_in_hello_world_db |
+---------------------------+
| books |
+---------------------------+
1 row in set (0.00 sec)Végül bontsa a kapcsolatot a MySQL szerverrel:
mysql> QUITEllenőrizte, hogy a book modell létrehozása sikeres volt. Ezzel a folyamattal bármennyi modellt létrehozhat azonos eljárás követésével.
Ebben a lépésben létrehoztál egy modellt az adatbázisban, és elindítottad a modell használatát beépített módszerekkel. Emellett a Sequelize által támogatott adattípusokat használtad a modell definiálásához. Ezután az alapvető modell-lekérdezésekkel fogsz dolgozni.
Sequelize használata adatbázis-lekérdezésekhez
Ebben a lépésben a Sequelize beépített lekérdezéseit fogja használni beszúráshoz, lekérdezéshez, feltételes lekérdezéshez és törléshez.
Új bejegyzés beszúrása
Az előző lépésben létrehoztál egy book modellt az adatbázison belül. Ebben a szakaszban adatokat fogsz beszúrni ebbe a modellbe.
A kezdéshez másolja át az előző lépésből a book.model.js tartalmát. Hozzon létre egy új fájlt book.controller.js néven, hogy kezelje a lekérdezési logikát. Adja hozzá a book.model.js kódját a book.controller.js fájlhoz.
A book.controller.js fájlban keresd meg a sync() metódust. A sync() metódusban add hozzá a következő kiemelt sorokat:
...
sequelize.sync().then(() => {
console.log('Book table created successfully!');
Book.create({
title: "Clean Code",
author: "Robert Cecil Martin",
release_date: "2021-12-14",
subject: 3
}).then(res => {
console.log(res)
}).catch((error) => {
console.error('Failed to create a new record : ', error);
});
}).catch((error) => {
console.error('Unable to create table : ', error);
});Itt egy új könyv rekordot szúrsz be a már létrehozott books modellbe a sync() metódus segítségével, amely támogatja új rekordok hozzáadását a korábban létrehozott modellekhez. Miután a sync() metódus sikeresen végrehajtódik, futtatja a then() metódust. A then() metóduson belül meghívod a create() metódust, hogy az új rekordokat beszúrd a modellbe.
A create() metódust használod arra, hogy az adatokat objektumként add át, amelyeket hozzá szeretnél adni az adatbázishoz. A kiemelt kódrészlet egy új bejegyzést szúr be a meglévő books tábládba. Ebben a példában hozzáadod a Clean Code című könyvet Robert Cecil Martin szerzőtől, amelyet a subject ID-jével, 3-mal kategorizáltak. Ugyanezt a kódot használhatod, más könyvek adataival frissítve, hogy új rekordokat adj a adatbázishoz.
Mentse el és zárja be a fájlt.
Futtassa az alkalmazást a következő parancs használatával:
node book.controller.jsA kimeneted hasonló lesz a következőhöz:
books {
dataValues:
{ id: 1,
title: 'Clean Code',
author: 'Robert Cecil Martin',
release_date: '2021-12-14',
subject: 3,
updatedAt: 2021-12-14T10:12:16.644Z,
...
}Új rekordot vittél fel a létrehozott modellhez az adatbázisban. Ugyanezzel a folyamattal további rekordokat is hozzáadhatsz.
Az összes rekord kijelölése
Ebben a részben kiválasztod és lekérdezed az összes könyv rekordot az adatbázisból a findAll() metódus használatával. Ehhez először nyisd meg a book.controller.js fájlt, és távolítsd el a korábbi Book.create() metódust. A sync() metódusban add hozzá a Book.findAll() metódust, ahogy az alább látható:
...
sequelize.sync().then(() => {
Book.findAll().then(res => {
console.log(res)
}).catch((error) => {
console.error('Failed to retrieve data : ', error);
});
}).catch((error) => {
console.error('Unable to create table : ', error);
});
...Mentse el és zárja be a fájlt.
Ezután futtassa újra az alkalmazást a következő parancs használatával:
node book.controller.jsA kimeneted hasonló lesz a következőhöz:
[
books {
dataValues: {
id: 1,
title: 'Clean Code',
author: 'Robert Cecil Martin',
release_date: '2020-01-01',
subject: 3,
createdAt: 2021-02-22T09:13:55.000Z,
updatedAt: 2021-02-22T09:13:55.000Z
},
_previousDataValues: {
id: 1,
title: 'Clean Code',
author: 'Robert Cecil Martin',
release_date: '2020-01-01',
subject: 3,
createdAt: 2021-02-22T09:13:55.000Z,
updatedAt: 2021-02-22T09:13:55.000Z
},
...
]A kimenet az összes könyv adatait egy tömb objektumként tartalmazza. Sikeresen használta a Sequelize findAll() metódusát, hogy visszaadja az összes könyv adatát az adatbázisból.
Kiválasztás a where feltétellel
Ebben a részben értékeket fogsz kiválasztani feltételekkel a where záradék segítségével. A where záradékot arra használjuk, hogy feltételt adjunk meg az adatok lekérésekor. Ebben a bemutatóban egy könyvet fogsz lekérni egy konkrét rekordazonosító alapján az adatbázisból a findOne() metódus segítségével.
Ehhez nyisd meg szerkesztésre a book.controller.js fájlt, töröld a findAll() metódust, és add hozzá a következő sorokat:
...
sequelize.sync().then(() => {
Book.findOne({
where: {
id: 1
}
}).then(res => {
console.log(res)
}).catch((error) => {
console.error('Failed to retrieve data : ', error);
});
}).catch((error) => {
console.error('Unable to create table : ', error);
});Itt egy konkrét könyv rekordot választasz ki az adatbázisból a findOne() módszerrel a where opció használatával. Ebben a példában azokat a könyvadatokat kérdezed le, amelyeknek a id értéke 1.
Mentse el és zárja be a fájlt.
Ezután futtasd az alkalmazást:
node book.controller.jsA kimeneted hasonló lesz a következőhöz:
books {
dataValues: {
id: 1,
title: 'Clean Code',
author: 'Robert Cecil Martin',
release_date: '2020-01-01',
subject: 'Science',
createdAt: 2021-02-22T09:13:55.000Z,
updatedAt: 2021-02-22T09:13:55.000Z
},
...
}Sikeresen használtad a where feltételeket adatok lekérésére a Sequelize modellekből. A where feltételt az adatbázis-alkalmazásban is használhatod feltételes adatok lekérésére.
Egy rekord törlése
Egy adott rekord törléséhez az adatbázis modellből a destroy() metódust használja a where opcióval. Ehhez nyissa meg a book.controller.js fájlt, távolítsa el a findOne() metódust, és adja hozzá a következő kiemelt sorokat:
...
sequelize.sync().then(() => {
Book.destroy({
where: {
id: 2
}
}).then(() => {
console.log("Successfully deleted record.")
}).catch((error) => {
console.error('Failed to delete record : ', error);
});
}).catch((error) => {
console.error('Unable to create table : ', error);
});Itt egy könyv rekordot távolítasz el az adatbázisból a destroy() metódus használatával a where opcióval, és megadva a törlendő könyv id-jét. Azt a könyv rekordot fogod eltávolítani, amelynek id-je 2.
Mentse el és zárja be a fájlt.
Ezután futtasd az alkalmazást:
node book.controller.jsA kimeneted a következőképpen fog kinézni:
Successfully deleted record.A bejegyzés törölve lett.
Ebben a lépésben kísérleteztél az adatbázismodelleddel és a modelllekérdezéssel. Elindítottad az adatbázist, létrehoztad a modelleket, beszúrtál rekordokat, lekértél rekordokat, lekértél rekordokat feltételekkel a where záradék használatával, majd töröltél kijelölt rekordokat. Ezzel a Sequelize-ről szerzett tudással most már képes leszel kapcsolatok létrehozására a Sequelize-ben. Ezután különböző típusú kapcsolatokat tudsz majd definiálni és kezelni a Sequelize modellek használatával.
Kapcsolatok létrehozása Sequelize használatával
Ebben a lépésben a Sequelize által támogatott szabványos kapcsolattípusokat fogja használni: egy az egyhez, egy a sokhoz és sok a sokhoz kapcsolatokat. Mintaadatokat fog használni diákokról, kurzusokról és osztályzatokról.
A Sequelize az alábbi adatbázis-kapcsolatokon alapuló társítási típusokat használ:
egy-egy kapcsolat: Az egy-egy kapcsolat azt jelenti, hogy az egyik táblában lévő rekord pontosan egy másik táblában lévő rekordhoz kapcsolódik. A Sequelize szempontjából ezt a típusú kapcsolatot a
belongsTo()és ahasOne()asszociációk használatával lehet létrehozni.egy-a-többhöz kapcsolat: Az egy-a-többhöz kapcsolat azt jelenti, hogy egy rekord az egyik táblában több rekordhoz kapcsolódik egy másik táblában. A Sequelize használatával a
hasMany()asszociációs metódusokat használhatja ennek a típusú kapcsolatnak a létrehozásához.sok-sokhoz kapcsolat: A sok-sokhoz kapcsolat azt jelenti, hogy egy tábla több rekordja több rekordhoz kapcsolódik egy másik táblában. A Sequelize segítségével a
belongsToMany()kapcsolatokkal hozhatsz létre ilyen típusú kapcsolatot.
Mielőtt létrehoznád ezeket a kapcsolatokat, először létrehozol egy új adatbázist student_db néven, majd hozzáadsz új modelleket és néhány mintaadatot a diákok, tanfolyamok és évfolyamok számára.
A adatbázis létrehozásához kövesse ugyanazt a folyamatot, mint a Sequelize telepítése és konfigurálása során, hogy be tudjon jelentkezni a MySQL-be, és hozzon létre egy student_db nevű adatbázist. Miután az új adatbázis létrejött, lépjen ki a MySQL-ből. Ezután elkezdheti az adatbázis-kapcsolatok létrehozását.
Egy egy-az-egyhez kapcsolat létrehozása a belongsTo() segítségével
Ebben a részben egy egy-az-egyhez kapcsolatot fogsz létrehozni a Sequelize modellek segítségével. Képzeld el, hogy szeretnéd megszerezni egy diák adatait a tanulmányi szintjével együtt. Mivel egy diáknak csak egy tanulmányi szintje lehet, ez a típusú kapcsolat egy egy-az-egyhez kapcsolatnak számít, és használhatod a belongsTo() metódust.
Megjegyzés: Különbség van a belongsTo() és a hasOne() között. A belongsTo() a foreignKey-t a forrástáblához adja, míg a hasOne() a cél táblához. Mindkét kapcsolat egyidejű használata esetén a Sequelize kétirányú egy-egy kapcsolatként fog működni.
A belongsTo() metódus lehetővé teszi, hogy egy-egy kapcsolatot hozz létre két Sequelize modell között. Ebben a példában a Student és a Grade modelleket használod.
Hozzon létre egy új fájlt one_to_one.js néven. Ahogy az előző részben, a MySQL adatbázishoz való csatlakozásnál tette, a fájl tetejére vegye fel a sorokat az adatbázishoz való kapcsolódáshoz és a MySQL felhasználó hitelesítéséhez. Ne felejtse el szükség szerint frissíteni a MySQL hitelesítő adatokat:
const { Sequelize, DataTypes } = require("sequelize");
const sequelize = new Sequelize(
'student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});Ebben a részben három modellt fogsz létrehozni az új student_db adatbázisban: Student, Grade és Course. Először a Student és a Grade modelleket fogod létrehozni. E lépés későbbi részében pedig a Courses modellt fogod létrehozni.
A Student modellhez add hozzá a következő kódblokkot a one_to_one.js fájlhoz:
...
const Student = sequelize.define("students", {
student_id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: DataTypes.STRING,
allowNull: false
}
});Ez a hallgatói modell két oszlopot tartalmaz: student_id és name.
Ezután adjunk hozzá egy kódblokkot a Grade modellhez:
...
const Grade = sequelize.define("grades", {
grade: {
type: DataTypes.INTEGER,
allowNull: false
}
});A Grade modell tartalmazza a grade oszlopot.
Ahhoz, hogy bemutasd az összefüggéseket, mintaadatokat kell hozzáadnod az adatbázishoz. Ehhez a bulk() módszert fogod használni. Ahelyett, hogy egyesével illesztenéd be az adatokat a sorokba, a bulkCreate() módszer lehetővé teszi, hogy egyszerre több sort illessz be az adatbázismodelljeidbe.
Most importáld a Grade és a Student adatokat a megfelelő modelljeikbe az adatbázisban a következőképpen:
...
const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]
const student_data = [
{name : "John Baker", gradeId: 2},
{name : "Max Butler", gradeId: 1},
{name : "Ryan Fisher", gradeId: 3},
{name : "Robert Gray", gradeId: 2},
{name : "Sam Lewis", gradeId: 1}
]
sequelize.sync({ force: true }).then(() => {
Grade.bulkCreate(grade_data, { validate: true }).then(() => {
Student.bulkCreate(student_data, { validate: true }).then(() => {
…
}).catch((err) => { console.log(err); });
}).catch((err) => { console.log(err); });
}).catch((error) => {
console.error('Unable to create the table : ', error);
});Itt mintaadatokat adsz meg, és beilleszted az adatokat a Student és a Grade modellekbe. A táblázatod, a modelljeid és a mintaadatok elkészülte után készen állsz az összefüggések létrehozására.
A one-to-one.js fájlban add hozzá a következő sort a student_data blokk alá:
...
Student.belongsTo(Grade);Ezután ellenőrizned kell, hogy az asszociáció megfelelően működik-e. Ehhez lekérheted az összes diák adatát a hozzájuk tartozó osztályzat szintekkel, ha a findAll() metódusban megadod az include paramétert.
Mivel meg kell szerezned a diák osztályzat szintjét, a modellt a Grade-ként adod át. A sequelize.sync() metódusban add hozzá a kiemelt sorokat a példában látható módon:
...
sequelize.sync({ force: true }).then(() => {
Grade.bulkCreate(grade_data, { validate: true }).then(() => {
Student.bulkCreate(student_data, { validate: true }).then(() => {
Student.findAll({
include: [{
model: Grade
}]
}).then(result => {
console.log(result)
}).catch((error) => {
console.error('Failed to retrieve data : ', error);
});
}).catch((err) => { console.log(err); });
}).catch((err) => { console.log(err); });
}).catch((error) => {
console.error('Unable to create the table : ', error);
});A teljes kód a következőképpen néz ki:
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});
const Student = sequelize.define("students", {
student_id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: DataTypes.STRING,
allowNull: false
}
});
const Grade = sequelize.define("grades", {
grade: {
type: DataTypes.INTEGER,
allowNull: false
}
});
const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]
const student_data = [
{name : "John Baker", gradeId: 2},
{name : "Max Butler", gradeId: 1},
{name : "Ryan Fisher", gradeId: 3},
{name : "Robert Gray", gradeId: 2},
{name : "Sam Lewis", gradeId: 1}
]
// One-To-One association
Student.belongsTo(Grade);
sequelize.sync({ force: true }).then(() => {
Grade.bulkCreate(grade_data, { validate: true }).then(() => {
Student.bulkCreate(student_data, { validate: true }).then(() => {
Student.findAll({
include: [{
model: Grade
}]
}).then(result => {
console.log(result)
}).catch((error) => {
console.error('Failed to retrieve data : ', error);
});
}).catch((err) => { console.log(err); });
}).catch((err) => { console.log(err); });
}).catch((error) => {
console.error('Unable to create the table : ', error);
});Mentse el és zárja be a fájlját.
Futtassa a fájlt a következő parancs használatával:
node one_to_one.jsA kimenet hosszú lesz, és az összes diák adatait az osztályszintjeikkel együtt láthatja. Íme egy részlet a kimenetből, amely a diákok adatait mutatja:
students {
dataValues:
{ student_id: '3e786a8f-7f27-4c59-8e9c-a8c606892288',
name: 'Sam Lewis',
createdAt: 2021-12-16T08:49:38.000Z,
updatedAt: 2021-12-16T08:49:38.000Z,
gradeId: 1,
grade: [grades] },
_previousDataValues:
...A használt parancssori eszközöktől függően a kimenet kibővített nézetben is megjelenhet, vagy nem. Ha kibővített nézetben jelenik meg, a kimenet a kibővített grade objektumot jeleníti meg.
Ebben a részben egy egy-egy kapcsolatot hoztál létre a Student.belongsTo(Grade); metódushívással, és az általad létrehozott kapcsolatnak megfelelő adatokat kaptad meg.
Egy-több kapcsolat létrehozása a hasMany() segítségével
Ebben a részben egy egy-a-többhöz kapcsolatot fogunk létrehozni Sequelize modellek segítségével. Képzeld el, hogy szeretnéd lekérni az összes hallgatót, akik egy kiválasztott évfolyamhoz tartoznak. Mivel egy adott évfolyamhoz több hallgató is tartozhat, ez egy egy-a-többhöz kapcsolat.
A kezdéshez másold a one_to_one.js tartalmát egy új fájlba, amelynek neve one_to_many.js. A one_to_many.js fájlban távolítsd el a sorokat a student_data blokk után. A one_to_many.js fájl így fog kinézni:
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});
const Student = sequelize.define("students", {
student_id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: DataTypes.STRING,
allowNull: false
}
});
const Grade = sequelize.define("grades", {
grade: {
type: DataTypes.INTEGER,
allowNull: false
}
});
const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]
const student_data = [
{name : "John Baker", gradeId: 2},
{name : "Max Butler", gradeId: 1},
{name : "Ryan Fisher", gradeId: 3},
{name : "Robert Gray", gradeId: 2},
{name : "Sam Lewis", gradeId: 1}
]A student_data blokk után használd a hasMany() metódust egy új kapcsolat létrehozásához:
...
Grade.hasMany(Student)A hasMany() metódus lehetővé teszi, hogy egy-egy kapcsolatot hozz létre két Sequelize modell között. Itt a Grade és a Student modelleket használod.
Ezután add hozzá a sequelize.sync() metódust a findAll() metódussal a hasMany() sor alá:
...
sequelize.sync({ force: true }).then(() => {
Grade.bulkCreate(grade_data, { validate: true }).then(() => {
Student.bulkCreate(student_data, { validate: true }).then(() => {
Grade.findAll({
where: {
grade: 9
},
include: [{
model: Student
}]
}).then(result => {
console.dir(result, { depth: 5 });
}).catch((error) => {
console.error('Failed to retrieve data : ', error);
});
}).catch((err) => { console.log(err); });
}).catch((err) => { console.log(err); });
}).catch((error) => {
console.error('Unable to create table : ', error);
});Itt éppen megpróbálod elérni az összes diákot egy adott évfolyamon – ebben az esetben az összes diákot a 9 évfolyamon. Hozzáadtad a Student modellt az include opcióhoz is.
Itt van a teljes kód:
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});
const Student = sequelize.define("students", {
student_id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: DataTypes.STRING,
allowNull: false
}
});
const Grade = sequelize.define("grades", {
grade: {
type: DataTypes.INTEGER,
allowNull: false
}
});
const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]
const student_data = [
{name : "John Baker", gradeId: 2},
{name : "Max Butler", gradeId: 1},
{name : "Ryan Fisher", gradeId: 3},
{name : "Robert Gray", gradeId: 2},
{name : "Sam Lewis", gradeId: 1}
]
// One-To-Many relationship
Grade.hasMany(Student);
sequelize.sync({ force: true }).then(() => {
Grade.bulkCreate(grade_data, { validate: true }).then(() => {
Student.bulkCreate(student_data, { validate: true }).then(() => {
Grade.findAll({
where: {
grade: 9
},
include: [{
model: Student
}]
}).then(result => {
console.dir(result, { depth: 5 });
}).catch((error) => {
console.error('Failed to retrieve data : ', error);
});
}).catch((err) => { console.log(err); });
}).catch((err) => { console.log(err); });
}).catch((error) => {
console.error('Unable to create table : ', error);
});Mentse el és zárja be a fájlját.
Futtassa a fájlt a következő parancs használatával:
node one_to_many.jsA kimenet a következőhöz hasonló lesz. Elég hosszú lesz, de az összes 9 osztályos diák a következőképpen lesz visszaadva:
[ grades {
dataValues:
{ id: 1,
grade: 9,
createdAt: 2021-12-20T05:12:31.000Z,
updatedAt: 2021-12-20T05:12:31.000Z,
students:
[ students {
dataValues:
{ student_id: '8a648756-4e22-4bc0-8227-f590335f9965',
name: 'Sam Lewis',
createdAt: 2021-12-20T05:12:31.000Z,
updatedAt: 2021-12-20T05:12:31.000Z,
gradeId: 1 },
...
students {
dataValues:
{ student_id: 'f0304585-91e5-4efc-bdca-501b3dc77ee5',
name: 'Max Butler',
createdAt: 2021-12-20T05:12:31.000Z,
updatedAt: 2021-12-20T05:12:31.000Z,
gradeId: 1 },
...Ebben a szakaszban egy egy-több kapcsolatot hoztál létre a Grade.hasMany(Student); metódushívással. A kimenetben az általad létrehozott kapcsolódás szerint szerezted be a részleteket.
Több-több kapcsolatok létrehozása a belongsToMany() segítségével
Ebben a részben a Sequelize modellek segítségével sok-sok kapcsolatokat fogsz létrehozni. Példaként képzelj el egy helyzetet, ahol a diákok különböző tanfolyamokra jelentkeznek be. Egy diák több tanfolyamra is beiratkozhat, és egy tanfolyamon több diák is részt vehet. Ez egy sok-sok kapcsolat. Ezt a Sequelize használatával úgy valósíthatod meg, hogy a Student, Course és StudentCourse modelleket használod a belongsToMany() metódussal.
A kezdéshez hozz létre egy many_to_many.js nevű fájlt, és add hozzá az adatbázis inicializálási és hitelesítési kódblokkokat az alábbiak szerint. (A kódblokkokat újra felhasználhatod az előző one_to_many.js példából.) Győződj meg róla, hogy szükség szerint frissíted a kiemelt adatbázis-kapcsolati értékeket.
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});Ezután létrehozod az adatbázis-modelleket a sok-sokhoz kapcsolat számára: Student és Course. Majd hozzáadsz néhány mintaadatot ezekhez a modellekhez.
...
const Student = sequelize.define("students", {
student_id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
},
name: {
type: DataTypes.STRING,
allowNull: false
}
});
const Course = sequelize.define("courses", {
course_name: {
type: DataTypes.STRING,
allowNull: false
}
});
const StudentCourse = sequelize.define('StudentCourse', {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
allowNull: false
}
});
const course_data = [
{course_name : "Science"},
{course_name : "Maths"},
{course_name : "History"}
]
const student_data = [
{name : "John Baker", courseId: 2},
{name : "Max Butler", courseId: 1},
{name : "Ryan Fisher", courseId: 3},
{name : "Robert Gray", courseId: 2},
{name : "Sam Lewis", courseId: 1}
]
const student_course_data = [
{studentId : 1, courseId: 1},
{studentId : 2, courseId: 1},
{studentId : 2, courseId: 3},
{studentId : 3, courseId: 2},
{studentId : 1, courseId: 2},
]Itt létrehozod a Student és Course modelleket, és biztosítasz néhány mintadata. Beállítasz egy courseID-t is, amelyet a diákok lekérdezéséhez fogsz használni ezen a kapcsolat típusa alapján.
Végül definiáltál egy új modellt StudentCourse néven, amely a Student és a Course közötti kapcsolati adatokat kezeli. Ebben a példában a studentId 1 be van iratkozva a courseId 1 és a courseId 2 kurzusokra.
Befejezted az adatbázis inicializálását és hozzáadtál mintaadatokat az adatbázishoz. Ezután hozz létre sok-sok kapcsolatok a belongsToMany() módszer használatával, az alábbi módon:
...
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})A belongsToMany() metóduson belül a through konfigurációt adjuk meg a modell nevével konfigurációs opcióként. Ebben az esetben ez a StudentCourse. Ez az az adatbázis-tábla, amely kezeli a sok-sok kapcsolatokat.
Végül ellenőrizheted, hogy az asszociáció megfelelően működik-e, ha lekérdezed az összes kurzis adatot a hozzá tartozó diákokkal együtt. Ezt úgy teheted meg, hogy a findAll() metóduson belül átadod az include paramétert. Add hozzá a következő sorokat a many_to_many.js fájlhoz:
...
sequelize.sync({ force: true }).then(() => {
Course.bulkCreate(course_data, { validate: true }).then(() => {
Student.bulkCreate(student_data, { validate: true }).then(() => {
StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
Course.findAll({
include: {
model: Student,
},
}).then(result => {
console.log(result);
}).catch((error) => {
console.error('Failed to retrieve data : ', error);
});
}).catch((error) => {
console.log(error);
});
}).catch((error) => {
console.log(error);
});
}).catch((error) => {
console.log(error);
});
}).catch((error) => {
console.error('Unable to create table : ', error);
});A teljes kód a következőképpen néz ki:
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});
const Student = sequelize.define("students", {
student_id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
},
name: {
type: DataTypes.STRING,
allowNull: false
}
});
const Course = sequelize.define("courses", {
course_name: {
type: DataTypes.STRING,
allowNull: false
}
});
const StudentCourse = sequelize.define('StudentCourse', {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true,
allowNull: false
}
});
const course_data = [
{course_name : "Science"},
{course_name : "Maths"},
{course_name : "History"}
]
const student_data = [
{name : "John Baker", courseId: 2},
{name : "Max Butler", courseId: 1},
{name : "Ryan Fisher", courseId: 3},
{name : "Robert Gray", courseId: 2},
{name : "Sam Lewis", courseId: 1}
]
const student_course_data = [
{studentId : 1, courseId: 1},
{studentId : 2, courseId: 1},
{studentId : 2, courseId: 3},
{studentId : 3, courseId: 2},
{studentId : 1, courseId: 2},
]
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})
sequelize.sync({ force: true }).then(() => {
Course.bulkCreate(course_data, { validate: true }).then(() => {
Student.bulkCreate(student_data, { validate: true }).then(() => {
StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
Course.findAll({
include: {
model: Student,
},
}).then(result => {
console.log(result);
}).catch((error) => {
console.error('Failed to retrieve data : ', error);
});
}).catch((error) => {
console.log(error);
});
}).catch((error) => {
console.log(error);
});
}).catch((error) => {
console.log(error);
});
}).catch((error) => {
console.error('Unable to create table : ', error);
});Mentse el és zárja be a fájlt.
Futtassa a fájlt a következő parancs használatával:
node many_to_many.jsA kimenet hosszú lesz, de valami hasonlóan fog kinézni:
[ courses {
dataValues:
{ id: 1,
course_name: 'Science',
createdAt: 2022-05-11T04:27:37.000Z,
updatedAt: 2022-05-11T04:27:37.000Z,
students: [Array] },
_previousDataValues:
{ id: 1,
course_name: 'Science',
createdAt: 2022-05-11T04:27:37.000Z,
updatedAt: 2022-05-11T04:27:37.000Z,
students: [Array] },
_changed: Set {},
_options:
{ isNewRecord: false,
_schema: null,
_schemaDelimiter: '',
include: [Array],
includeNames: [Array],
includeMap: [Object],
includeValidated: true,
attributes: [Array],
raw: true },
isNewRecord: false,
students: [ [students], [students] ] },
courses {
dataValues:
{ id: 2,
course_name: 'Maths',
createdAt: 2022-05-11T04:27:37.000Z,
updatedAt: 2022-05-11T04:27:37.000Z,
students: [Array] },
_previousDataValues:
...Ahogy az outputból látható, a hallgatókkal társított kurzusok kerültek lekérdezésre. A courses blokkban külön id értékeket fogsz látni, amelyek az egyes kurzusokat jelzik. Például a id: 1 a course_name: Science kurzushoz tartozik a Természettudományok osztályban, míg a id: 2 a Matematikai osztály, és így tovább.
Az adatbázisban láthatod a három létrehozott táblát a beillesztett mintaadatokkal.
Ebben a lépésben a Sequelize-t használtad egy-az-egyhez, egy-a-többhöz és több-a-többhöz kapcsolatok létrehozására. Ezután nyers lekérdezésekkel fogsz dolgozni.
Nyers lekérdezésekkel való munka
Ebben a lépésben nyers lekérdezésekkel fogsz dolgozni a Sequelize-ben. Az előző lépésekben a Sequelize beépített metódusait, például a insert() és a findAll() metódusokat használtad az adatok beszúrására és lekérdezésére az adatbázisból. Lehet, hogy észrevetted, hogy ezek a metódusok egy meghatározott mintát követnek a lekérdezés írásakor. A nyers lekérdezések használatával azonban nem kell aggódnod a Sequelize beépített metódusai és mintái miatt. Az SQL lekérdezésekről szerzett ismereteidet felhasználva a Sequelize-ben egyszerűtől a haladóig terjedő lekérdezéseket végezhetsz.
Itt egy példa nyers lekérdezésekre, amelyek végrehajtják azt a műveletet, hogy kiválasztják az összes értéket egy adott táblából, törlik a kiválasztott értékeket a feltétel szerint, és frissítik a táblát a megadott értékekkel.
SELECT * FROM table_name;
DELETE FROM table_name WHERE condition;
UPDATE table_name SET y = 42 WHERE x = 12;A Sequelize-ben a nyers lekérdezések elsősorban két módszerrel használhatók: tömbös csere és objektumos csere. Amikor értékeket adsz át az SQL lekérdezéshez, használhatsz ehhez vagy egy tömböt, vagy egy objektumot.
Mielőtt nyers lekérdezést írnál, először meg kell adnod a hallgatói adatokat egy mintaadatbázisban. A korábbi rész, a Mintaadatbázis létrehozása után jelentkezz be a MySQL-be, hozz létre egy sample_student_db nevű adatbázist, majd lépj ki a MySQL-ből.
Ezután néhány nyers adatot fogsz hozzáadni, hogy elkezdhess dolgozni nyers lekérdezésekkel. Hozz létre egy új fájlt add_student_records.js néven, és add hozzá a következő kódrészleteket, amelyek a korábban megbeszélt Sequelize metódusokat tartalmazzák: authenticate(), sync() és bulkCreate().
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'sample_student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});
const Student = sequelize.define("students", {
student_id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: DataTypes.STRING,
allowNull: false
}
});
const student_data = [
{name : "John Baker"},
{name : "Max Butler"},
{name : "Ryan Fisher"},
{name : "Robert Gray"},
{name : "Sam Lewis"}
]
sequelize.sync({ force: true }).then(() => {
Student.bulkCreate(student_data, { validate: true }).then((result) => {
console.log(result);
}).catch((error) => {
console.log(error);
});
}).catch((error) => {
console.error('Unable to create table : ', error);
});Itt elindítja az adatbázis-kapcsolatot, létrehozza a modellt, és néhány hallgatói rekordot szúr be az új adatbázisba.
Mentse el és zárja be a fájlt.
Ezután futtassa a szkriptet a következő parancs használatával:
node add_student_records.jsA kimenet valami hasonló lesz a következőhöz. Elég hosszú lesz, de minden olyan diákadat, amelyet beillesztettél, a következőképpen kerül visszaadásra. Ne feledd, hogy mivel a student_id egy automatikusan generált UUID (Globálisan Egyedi Azonosító) érték, a felhasználótól függően eltérő lesz.
Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `students`;
Connection has been established successfully.
Executing (default): DROP TABLE IF EXISTS `students`;
Executing (default): CREATE TABLE IF NOT EXISTS `students` (`student_id` CHAR(36) BINARY , `name` VARCHAR(255) NOT NULL, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`student_id`)) ENGINE=InnoDB;
Executing (default): SHOW INDEX FROM `students`
Executing (default): INSERT INTO `students` (`student_id`,`name`,`createdAt`,`updatedAt`) VALUES ('45d1f26c-ba76-431f-ac5f-f41282351710','John Baker','2022-06-03 07:27:49','2022-06-03 07:27:49'),('1cb4e34d-bfcf-4a97-9624-e400b9a1a5f2','Max Butler','2022-06-03 07:27:49','2022-06-03 07:27:49'),('954c576b-ba1c-4dbc-a5c6-8eaf22bbbb04','Ryan Fisher','2022-06-03 07:27:49','2022-06-03 07:27:49'),('e0f15cd3-0025-4032-bfe8-774e38e14c5f','Robert Gray','2022-06-03 07:27:49','2022-06-03 07:27:49'),('826a0ec9-edd0-443f-bb12-068235806659','Sam Lewis','2022-06-03 07:27:49','2022-06-03 07:27:49');
[
students {
dataValues: {
student_id: '45d1f26c-ba76-431f-ac5f-f41282351710',
name: 'John Baker',
createdAt: 2022-06-03T07:27:49.453Z,
updatedAt: 2022-06-03T07:27:49.453Z
},
_previousDataValues: {
name: 'John Baker',
student_id: '45d1f26c-ba76-431f-ac5f-f41282351710',
createdAt: 2022-06-03T07:27:49.453Z,
updatedAt: 2022-06-03T07:27:49.453Z
},
…A következő szakaszban nyers lekérdezéseket fogsz alkalmazni az egyik student_id kimenet felhasználásával a fenti kódrészletből. Másold le, hogy meglegyen a következő szakaszokhoz, ahol a query() módszert fogod használni tömb- és objektumcserékhez.
Tömbcsere
Ebben a részben az query() metódust fogod használni egy tömb helyettesítésére. Ezzel a módszerrel a Sequelize képes nyers vagy előre elkészített SQL lekérdezések végrehajtására.
Az induláshoz másold a 1. lépésben található server.js fájl tartalmát, mivel az tartalmazza a Sequelize() inicializáló metódust és az adatbázis inicializálását. Illeszd be a tartalmat egy új fájlba, amit array_raw_query.js-nek nevezel el. Frissítsd az adatbázis nevét sample_student_db-re:
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'sample_student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});A fájl végére illessze be a következő kódrészletet egy tömb cseréjéhez, ügyelve arra, hogy a REPLACE_STUDENT_ID helyére a korábbi szakaszban másolt student_id értéket írja.
...
sequelize.query(
'SELECT * FROM students WHERE student_id = ?',
{
replacements: ['REPLACE_STUDENT_ID'],
type: sequelize.QueryTypes.SELECT
}
).then(result => {
console.log(result);
}).catch((error) => {
console.error('Failed to insert data : ', error);
});Tömbcseréhez a query() metódusnak adod át az SQL lekérdezést és a konfigurációs objektumot. Ez tartalmazza a replacements értéket és típusát. A cserékhez az adatokat tömb formájában adod át, és ezekre az értékekre a kérdőjel (?) szimbólummal hivatkozhatsz.
Ezután, mivel adatot kell lekérnie egy adott diákhoz, a student_id kerül átadásra második paraméterként. Ezt követően átadja a type: sequelize.QueryTypes.SELECT kulcs-érték párt, amelyet az adatbázisból történő adatlekéréshez használhat.
Vannak más típusok is, például QueryTypes.UPDATE és QueryTypes.DELETE. A követelménytől függően kiválaszthatod a célodnak legmegfelelőbb típust.
A következő a teljes kódrészletet mutatja. Itt csatlakozol az adatbázishoz, és egy nyers lekérdezés segítségével lekérdezed a kiválasztott tanulói adatokat.
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'sample_student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});
sequelize.query(
'SELECT * FROM students WHERE student_id = ?',
{
replacements: ['REPLACE_STUDENT_ID'],
type: sequelize.QueryTypes.SELECT
}
).then(result => {
console.log(result);
}).catch((error) => {
console.error('Failed to insert data : ', error);
});Mentse el és zárja be a fájlt.
Ezután a következő parancs használatával futtathatja ezt a szkriptet:
node array_raw_query.jsA következőhöz hasonló kimenetet fogsz látni:
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
name: 'Robert Gray',
createdAt: 2022-05-06T13:14:50.000Z,
updatedAt: 2022-05-06T13:14:50.000Z } ]A kiválasztott student_id miatt az eredményeid értékei eltérhetnek.
Objektum cseréje
A felszínen az objektumcsere hasonló a tömbcserehez, de az adatok nyers lekérdezésbe való átadásának módja különbözik. A csere opcióban adatokat objektumként adunk át, míg a lekérdezés opcióban olyan értékeket használunk, mint a :key.
A kezdéshez hozz létre egy új fájlt object_raw_query.js néven, majd másold be a teljes kódblokkokat a server.js fájlból, frissítve az adatbázist sample_student_db-re.
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'sample_student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});Ezután add hozzá a következő kódrészletet az új object_raw_query.js fájl végére:
...
sequelize.query(
'SELECT * FROM students WHERE student_id = :id',
{
replacements: { id: 'REPLACE_STUDENT_ID' },
type: sequelize.QueryTypes.SELECT
}
).then(result => {
console.log(result);
}).catch((error) => {
console.error('Failed to insert data : ', error);
});Itt a kijelölt tanulói adatokat az objektumcsere módszerével kapod meg. Létrehozol egy replacement objektumot, beállítva az id-t a lekérdezni kívánt tanulói információként: { id: 'REPLACE_STUDENT_ID' }.
A query() metódusban így adod meg: 'SELECT * FROM students WHERE student_id=:id'. A query() metódus használatával a helyettesítő értéket objektumként adod át, ezért ezt a módszert objektum helyettesítésnek nevezik.
Itt van a teljes kód:
const {Sequelize, DataTypes} = require("sequelize");
const sequelize = new Sequelize(
'sample_student_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});
sequelize.query(
'SELECT * FROM students WHERE student_id = :id',
{
replacements: { id: 'REPLACE_STUDENT_ID' },
type: sequelize.QueryTypes.SELECT
}
).then(result => {
console.log(result);
}).catch((error) => {
console.error('Failed to insert data : ', error);
});Mentse el és zárja be a fájlt.
Ezután futtassa a szkriptet a következő parancs használatával:
node object_raw_query.jsA kimenet hasonló lesz a következőhöz:
Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
name: 'Robert Gray',
createdAt: 2022-05-06T13:14:50.000Z,
updatedAt: 2022-05-06T13:14:50.000Z } ]A kiválasztott student_id miatt az eredményeid értékei eltérhetnek.
Ebben a lépésben a Sequelize nyers lekérdezéseivel dolgoztál két különböző módszerrel: tömbhelyettesítéssel és objektumhelyettesítéssel.
Környezeti változók konfigurálása a biztonságos adatbázis-kapcsolatokhoz
Eddig közvetlenül a kódodban tároltad az adatbázis-hitelesítő adatokat. Bár ez a megközelítés helyi kísérletezéshez működik, nem biztonságos. A hitelesítő adatok keménykódolása érzékeny információkat, például adatbázis-jelszavakat és hosztneveket tárhat fel, és növeli a betörések kockázatát, amikor a kódot megosztják vagy telepítik. Ebben a részben megtanulod, hogyan tárolhatod ezeket a hitelesítő adatokat biztonságosan környezeti változók használatával.
Miért használjunk környezeti változókat?
A környezeti változók külső konfigurációs paraméterként működnek, amelyeket az alkalmazás futásidőben olvashat. Ahelyett, hogy a hitelesítő adatokat közvetlenül a kódba ágyaznád, azok a rendszeredben vagy egy külön konfigurációs fájlban tárolódnak, amelyet soha nem commitolnak a verziókezelőbe. Ez a megközelítés több előnnyel jár:
- Biztonság: A hitelesítő adataid rejtve maradnak a nyilvános tárolóktól és a verziókezelő rendszerektől.
- Rugalmasság: Minden környezet (fejlesztés, tesztelés, éles) eltérő adatbázis-konfigurációt használhat anélkül, hogy a forráskódot módosítani kellene.
- Fenntarthatóság: A központosított konfiguráció lehetővé teszi az egyszerű frissítéseket; ha a adatbázis jelszó megváltozik, csak egy fájlt vagy változót kell módosítania.
- Megfelelés: Ez a gyakorlat összhangban van a Twelve-Factor App módszertannal, amely a környezet-specifikus konfigurációkezelést támogatja a skálázható alkalmazásokhoz.
Környezeti változók beállítása
A Node.js környezeti változóinak kezeléséhez a dotenv csomagot fogod használni. Ez a könyvtár a .env fájlból olvassa be a változókat, majd beilleszti őket a Node.js process.env objektumba, így azok az alkalmazásod egészében hozzáférhetők lesznek.
Telepítsd a dotenv csomagot a következő parancs futtatásával:
npm install dotenvTelepítés után hozz létre egy új fájlt .env névvel a projekted gyökérkönyvtárában. Ez a fájl fogja tartalmazni az összes érzékeny adatot, amely a adatbázis-kapcsolathoz szükséges.
Íme egy példa .env fájl konfiguráció a Sequelize beállításához:
DB_NAME=hello_world_db
DB_USER=your_username
DB_PASSWORD=your_password
DB_HOST=localhost
DB_DIALECT=mysqlMinden változó egy adott paraméterhez tartozik, amelyet a Sequelize a kapcsolat létrehozásához használ.
A .env fájl biztonságossá tétele
Létfontosságú, hogy a .env fájl soha ne jelenjen meg a verziókezelésben. Ennek megelőzésére add hozzá a .gitignore fájlodhoz, így a Git figyelmen kívül hagyja a változtatások commitolásakor:
.envTermelési környezetben a környezeti változókat általában közvetlenül a hosztingplatform beállításaiban vagy titoktárolójában konfigurálják, nem pedig egy helyi .env fájlban.
A Sequelize beállításainak frissítése
Most, hogy definiáltad a környezeti változókat, frissítsd a Sequelize inicializálásodat, hogy azokat használd. Kezdd azzal, hogy importálod és konfigurálod a dotenv-t a fő szerverfájlod tetején (például server.js):
require('dotenv').config();
const Sequelize = require('sequelize');
const sequelize = new Sequelize(
process.env.DB_NAME,
process.env.DB_USER,
process.env.DB_PASSWORD,
{
host: process.env.DB_HOST,
dialect: process.env.DB_DIALECT
}
);
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database:', error);
});- A
require('dotenv').config()sor betölti az összes változót, amely a.envfájlban van definiálva aprocess.envobjektumba. - A Sequelize az új példány inicializálásakor olvassa be a környezeti változókat.
- Ez biztosítja, hogy a felhasználónevekhez vagy jelszavakhoz hasonló érzékeny információk ne jelenjenek meg a kódodban.
Ez a megközelítés növeli a biztonságot, és lehetővé teszi, hogy különböző környezetek egyszerűen azonosítsák a saját konfigurációikat azzal, hogy megváltoztatják a környezeti változók értékeit.
A konfiguráció ellenőrzése
Miután frissítetted a konfigurációdat, ellenőrizheted a kapcsolatot a Node.js alkalmazásod futtatásával:
node server.jsHa a .env fájlod megfelelően van beállítva és a MySQL szerver fut, a következő kimenetet fogod látni:
Connection has been established successfully.Ha hiba jelenik meg, ellenőrizze, hogy:
- A
.envfájlban szereplő hitelesítő adatok megegyeznek a MySQL példányodéival. - A MySQL szerver fut, és elérhető a gépedről.
- A
.envfájl a projekt gyökérkönyvtárában található, és megfelelően van formázva.
Legjobb gyakorlatok a biztonságos konfigurációhoz
A környezeti változók használata erős első lépés a biztonságos konfigurációkezelés felé. A folyamatos biztonság és megbízhatóság érdekében érdemes figyelembe venni a következő további legjobb gyakorlatokat:
- Használj külön konfigurációkat környezetenként: Tarts fenn külön
.envfájlokat adevelopment,stagingésproductionkörnyezetekhez. Elnevezheted őket.env.development,.env.stagingés.env.productionnéven. - Használj titoktárolókat: Éles környezetben a titkok fájlokban való tárolása helyett titoktárolókat használj.
- Érvényesítse a környezeti változókat: Használjon konfigurációs segédprogramot vagy indító szkriptet, amely ellenőrzi, hogy a szükséges változók definiálva vannak-e az alkalmazás futtatása előtt. Ez segít megelőzni a futásidejű hibákat.
- Rendszeresen cserélje a hitelesítő adatokat: Frissítse az adatbázis-hitelesítő adatokat időszakosan, hogy csökkentse a potenciális szivárgások hatását.
- Adatbázis-hozzáférés korlátozása: Állítsa be az adatbázis felhasználói szerepeit úgy, hogy csak a szükséges legkisebb jogosultságokkal rendelkezzenek az alkalmazás számára.
Azáltal, hogy környezeti változókat használsz és követed ezeket a gyakorlatokat, biztosítod, hogy a Sequelize alkalmazásod mind a fejlesztési, mind a termelési környezetben megőrizze a rugalmasságot és a biztonságot.
Migráció és szinkronizálás legjobb gyakorlatai
Amikor egy adatbázis-sémát fejlesztesz, a Sequelize-nál két fő megközelítésed van: explicit migrációk írása és futtatása, vagy a sequelize.sync() használata, hogy a Sequelize automatikusan generálja a séma változtatásokat. Mindkét megközelítés érvényes, de más célokat szolgálnak, és különböző kompromisszumokkal járnak. Nézzük meg, mikor érdemes melyiket használni, hogyan írjunk biztonságos migrációkat, és hogyan futtassuk őket megbízhatóan fejlesztésben és éles környezetben.
Migrációk vagy sequelize.sync() — mikor melyiket használjuk
Változtatások (ajánlott éles környezetben): A változtatások a sémádra vonatkozó kifejezett, verziózott módosítások. Ezek a forráskód-kezelésben vannak tárolva, kódellenőrzésen mennek át, és a telepítési folyamat részeként hajtódnak végre. Használj változtatásokat éles környezetben minden olyan séma módosítás esetén, amely az adatok integritását vagy rendelkezésre állását érinti.
sequelize.sync()(csak fejlesztéshez és prototípusokhoz használható): Async()kényelmes a helyi fejlesztéshez, teszteléshez és gyors prototípusokhoz, mert automatikusan létrehozhatja vagy módosíthatja a táblákat. Azonban ne használd async({ force: true })vagysync({ alter: true })beállításokat éles környezetben: ezek az opciók adatvesztést okozhatnak vagy biztonság nélküli változtatásokat eszközölhetnek visszaállítási lehetőség nélkül.
Eszközök: sequelize-cli és migrációs futtatók
A hivatalos parancssori eszköz, a sequelize-cli, a legegyszerűbb módja a migrációk kezelésének a Sequelize-vel. Azoknak a csapatoknak, akik nagyobb irányítást vagy egyedi munkafolyamatokat igényelnek, a umzug egy népszerű alternatíva.
A CLI telepítéséhez és inicializálásához a projektedben futtasd a következőt:
npm install --save-dev sequelize-cli
npx sequelize-cli initEz a következő mappákat hozza létre:
config/ # Stores database configuration files
models/ # Stores your Sequelize model definitions
migrations/ # Stores migration files
seeders/ # Stores seeder files for inserting initial dataEzeket a mappákat hozzá kell adnod a verziókezeléshez (kivéve az olyan fájlokat, amelyek hitelesítő adatokat tartalmaznak). Ez biztosítja, hogy minden környezet ugyanazokat az adatbázis-módosításokat következetesen futtassa.
Migrációk létrehozása és futtatása
Új migrációs fájl létrehozásához használd a következő parancsot:
npx sequelize-cli migration:generate --name add-isbn-to-booksEz egy időbélyeggel ellátott fájlt hoz létre a migrations/ mappában. Nyisd meg a fájlt, és határozd meg, mi történjen a migráció alkalmazásakor (up), és hogyan lehet azt visszavonni (down):
module.exports = {
async up(queryInterface, Sequelize) {
await queryInterface.addColumn('books', 'isbn', {
type: Sequelize.STRING
});
},
async down(queryInterface) {
await queryInterface.removeColumn('books', 'isbn');
}
};- Az
upfüggvény végrehajtja a migrációt (hozzáadja az oszlopot). - A
downfüggvény visszavonja a módosítást (eltávolítja az oszlopot).
Futtassa a migrációt a következőkkel:
npx sequelize-cli db:migrateA legutóbbi migráció visszavonásához használd:
npx sequelize-cli db:migrate:undoFejlesztés közben az összes migrációt a következő futtatásával is visszavonhatod:
npx sequelize-cli db:migrate:undo:allBiztonságos, idempotens migrációk írása
Kövesd ezeket a szabályokat a migrációk készítésekor:
Wrap műveleteket tranzakciókba, amikor az adatbázis támogatja. Ez biztosítja, hogy a migráció vagy teljesen sikeres legyen, vagy hiba esetén teljesen visszavonódjon.
module.exports = { async up(queryInterface, Sequelize) { return queryInterface.sequelize.transaction(async (t) => { await queryInterface.addColumn('books', 'isbn', { type: Sequelize.STRING }, { transaction: t }); }); }, async down(queryInterface) { return queryInterface.sequelize.transaction(async (t) => { await queryInterface.removeColumn('books', 'isbn', { transaction: t }); }); } };Tartsd a migrációkat kicsinek és fókuszáltnak. Minden migrációnak egyetlen logikai változást kell végrehajtania (oszlop hozzáadása, index létrehozása, oszlop átnevezése). A kisebb migrációk könnyebben áttekinthetők, tesztelhetők és visszaállíthatók.
Legyél óvatos és idempotens. Ha szükséges, ellenőrizd a létezést, hogy elkerüld a hibákat olyan környezetekben, ahol eltérés van. Használd a
queryInterface.describeTable()-t vagy nyers lekérdezéseket a műveletek védelmére.Kerülje a destruktív műveleteket egy lépésben. Például egy oszlop biztonságos eltávolításához hozza létre az új oszlopot, töltsön vissza adatokat, váltson át az alkalmazás kódjában az új oszlopra történő olvasásra, majd csak ezután törölje a régi oszlopot egy későbbi migráció során.
Hosszú ideig tartó és leállás nélküli átállítások
A nagy táblák és indexműveletek zárolásokat okozhatnak. Használja ezeket a stratégiákat a hatás minimalizálására:
- Először adjunk hozzá nullable oszlopokat. Egy nullable oszlop hozzáadása általában gyors. Kerüld az olyan oszlopok hozzáadását, amelyek nem triviális alapértelmezett értékeket kapnak, mert ezek teljes táblát érintő újraírást válthatnak ki.
- Töltsd fel kis adagokban. Valósíts meg egy háttérfolyamatot, amely darabonként tölti fel az új oszlopokat ahelyett, hogy egyetlen hatalmas
UPDATE-et futtatnál. CONCURRENTLYés a legújabb MySQL online DDL) nyers SQL-en keresztül a migrációkban.- Funkciókapcsoló-kibocsátások. Telepítse az alkalmazáskódot úgy, hogy az új oszlopot egy funkciókapcsoló mögött olvassa. Miután a visszatöltés befejeződik és a tesztek sikeresen lefutnak, kapcsolja át a kapcsolót, majd később távolítsa el a régi mezőt.
Visszaállítások és sürgősségi javítások
- Adj meg egy
downmigrációt. Mindenup-nak kell, hogy legyen egy visszafelé irányulódown, ami dokumentálja, hogyan lehet visszavonni a változtatást. Még ha ritkán is futtatod adown-t éles környezetben, világos visszaállítási tervet biztosít. - Tervezzen vészhelyzeti visszaállításokat. Ha egy migráció problémákat okoz, legyen felkészülve arra, hogy először az alkalmazáskódot állítsa vissza, és szükség esetén a adatbázist a biztonsági mentésekből. Rendszeresen tesztelje a visszaállítási eljárásokat.
Adatok és séma módosításainak feltöltése
- Tartsd a seedereket minimálisnak és stabilnak. Használj seedereket csak alapvető keresési vagy konfigurációs sorokhoz. Kerüld el nagy mennyiségű üzleti adat migrációkon keresztüli seedelését.
- Válaszd szét a magokat a strukturális migrációktól. Ha olyan adatokat kell feltöltened, amelyek egy sémaváltozástól függenek, inkább egy külön seeder-t használj, hogy a felelősségek világosak maradjanak.
CI, kódáttekintés és telepítési automatizálás
Futtasd a migrációkat először a CI-ben és a staging környezetben. Adj hozzá egy CI lépést, ami egy ideiglenes adatbázison futtatja a migrációkat, hogy korán észrevehetőek legyenek a hibák.
Kezeld a migrációkat úgy, mint a kódot. Ellenőrizd és vizsgáld át a migrációs fájlokat a pull requestekben. Lehetőség szerint építs be automatikus ellenőrzéseket is.
Automatizálja a migrációk végrehajtását a telepítések során. Biztosítsa, hogy a migrációk lefussanak, mielőtt az alkalmazás folyamatai forgalmat fogadnának. Példa
package.jsonszkriptek:"scripts": { "migrate": "npx sequelize-cli db:migrate", "start": "node server.js", "deploy": "npm run migrate && npm run start" }
Konténerizált telepítések esetén futtassa a migrációkat init konténerként vagy telepítési hookban, így a webfolyamatok csak a migrációk befejezése után indulnak el.
Migrációk tesztelése
- Teszteld mindkét irányt. Futtasd a
db:migratemajd adb:migrate:undo:allparancsot helyileg és a CI-ben, hogy ellenőrizd, mind aup, mind adownműködik. - Használjon eldobható adatbázisokat a tesztekhez. Előnyben részesítse az átmeneti adatbázisokat vagy konténereket a determinisztikus tesztfuttatásokhoz.
Ezeknek a bevált gyakorlatoknak a követése biztosítja, hogy a Sequelize migrációid megbízhatóak, nyomon követhetőek és hosszú távú projektek számára is biztonságosak maradjanak.
Hibaelhárítás és teljesítmény tippek
Még egy jól beállított környezet mellett is előfordulhat, hogy a Sequelize alkalmazások váratlan problémákkal szembesülnek, például adatbázis-kapcsolati hibákkal, migrációs kudarcokkal, lassú lekérdezésekkel, holtpontokkal vagy párhuzamossági konfliktusokkal. Ez a rész lépésről lépésre útmutatást nyújt ezeknek a problémáknak az azonosításához és javításához, valamint teljesítménybeli bevált gyakorlatokat is tartalmaz, amelyek segítenek az alkalmazás stabil és hatékony működésének fenntartásában.
Gyakori problémák elhárítása
1. Kapcsolati hibák
Probléma: A Sequelize nem tud csatlakozni a MySQL adatbázishoz, és olyan hibákat dob, mint például SequelizeConnectionError: connect ECONNREFUSED, Access denied for user vagy SequelizeHostNotFoundError.
Hogyan javítsuk:
Kezdje azzal, hogy megerősíti, helyesek-e a csatlakozási adatai. Ellenőrizze újra a .env fájlban szereplő értékeket, beleértve az adatbázis nevét, felhasználónevét, jelszavát, hosztját és portját. Még egy apró elírás vagy felesleges szóköz is okozhatja, hogy a Sequelize nem tud csatlakozni.
Ezután győződjön meg róla, hogy a MySQL szervere fut és hallgat a alapértelmezett porton (3306). A csatlakozást manuálisan bejelentkezve is tesztelheti:
mysql -u your_username -p -h your_host -P 3306Ha ez a parancs meghiúsul, a probléma valószínűleg a MySQL szolgáltatásával vagy a hitelesítő adataival van.
Ha a dotenv csomagot használja, győződjön meg róla, hogy a require('dotenv').config() mielőtt a Sequelize inicializálódna, szerepel. Ez a lépés biztosítja, hogy minden környezeti változó elérhető legyen futásidőben.
Végül, távoli kapcsolatok esetén ellenőrizze a tűzfal beállításait vagy a biztonsági csoport szabályait. A MySQL szervernek engedélyeznie kell a bejövő kapcsolatokat az alkalmazás hostjáról.
2. Migrációs sikertelenségek
Probléma: Ha futtatod a npx sequelize-cli db:migrate vagy sequelize.sync() parancsot, olyan hibákkal találkozhatsz, mint hiányzó táblák, duplikált oszlopok vagy sémaeltérések.
Hogyan javítsuk:
A migrációs problémák általában akkor jelentkeznek, ha a fájlokat rossz sorrendben futtatják, vagy hibákat tartalmaznak az SQL műveletekben. A Sequelize a migrációkat a fájlnevekben található időbélyegek alapján dolgozza fel, ezért ellenőrizze, hogy a fájlok megfelelően vannak-e elnevezve.
Ha egy migráció sikertelen, részletesen ellenőrizze a hibaüzenetet. Ezután biztonságosan vonja vissza az utolsó migrációt a következővel:
npx sequelize-cli db:migrate:undoA migrációs fájl javítása után futtasd újra.
Mindig csomagold a migrációs logikádat egy tranzakció belsejébe az atomi műveletek biztosítása érdekében: vagy minden változtatás sikeres, vagy egyik sem. A migrációk éles környezetben történő futtatása előtt alaposan teszteld őket egy teszt- vagy helyi adatbázison, hogy megerősítsd a helyességüket.
3. Modell szinkronizációs problémák
Probléma: A Sequelize modelljeid és az adatbázis-sémád nem egyeznek, ami hiányzó oszlopokhoz, hibás adattípusokhoz vagy elavult táblákhoz vezet.
Hogyan javítsuk:
Kerülje a sequelize.sync({ force: true }) használatát éles környezetben, mivel ez törli és újra létrehozza a táblákat, ami visszafordíthatatlan adatvesztést okozhat. Hasonlóképpen, a sequelize.sync({ alter: true }) használatát is óvatosan végezze; ez a sémákat kiszámíthatatlan módon módosíthatja.
Ehelyett részesítsd előnyben az olyan explicit migrációkat, amelyek világosan meghatározzák az összes sémaváltozást. A modellek tényleges adatbázis-struktúrával való összehasonlításához használd:
await queryInterface.describeTable('tableName');Ez segít az eltérések azonosításában, mielőtt azok befolyásolnák a gyártást.
4. Lekérdezési és időtúllépési hibák
Probléma: Időtúllépéssel kapcsolatos hibákat látsz, például Connection timeout vagy Too many connections.
Hogyan javítsuk:
A időtúllépési problémákat gyakran a kimerült kapcsolati medencék vagy a nem lezárt kapcsolatok okozzák. Győződj meg róla, hogy minden Sequelize lekérdezést megfelelően várakoztatsz, hogy a kapcsolatok használat után visszakerüljenek a medencébe.
Finomhangolhatod a Sequelize kapcsolatkezelőinek beállításait is, hogy jobban illeszkedjenek az alkalmazásod terheléséhez:
const sequelize = new Sequelize(DB_NAME, DB_USER, DB_PASSWORD, {
host: DB_HOST,
dialect: 'mysql',
pool: {
max: 10,
min: 0,
acquire: 30000,
idle: 10000
}
});Ha az alkalmazásod sok egyidejű felhasználót kezel, érdemes növelni a MySQL max_connections paraméterét az adatbázis-konfigurációdban. Figyeld az aktív kapcsolatokat a MySQL-ben a SHOW PROCESSLIST; parancs segítségével, hogy észrevedd a szivárgásokat vagy a nem használt munkameneteket.
5. Lassú lekérdezés teljesítmény
Probléma: Bizonyos lekérdezések jelentősen hosszabb ideig tartanak a vártnál, ami lassú API-válaszokat vagy magas késleltetést eredményez.
Hogyan állapítsuk meg a diagnózist:
Kezdd azzal, hogy azonosítod, mely lekérdezések lassúak. Minden Sequelize által végrehajtott lekérdezést naplózhatsz úgy, hogy ideiglenesen engedélyezed a naplózást:
const sequelize = new Sequelize(..., { logging: console.log });Ezután használd a MySQL EXPLAIN utasítását, hogy megértsd, hogyan hajtja végre az adatbázis a lekérdezést:
EXPLAIN SELECT * FROM users WHERE email = 'user@example.com';Ha a kimenet „teljes táblavizsgálatot” mutat, a lekérdezéshez hiányzik egy index.
A MySQL lassú lekérdezések naplója is engedélyezhető az automatikus lassú műveletek rögzítéséhez:
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1;Hogyan javítsuk:
Adj hozzá indexeket a gyakran lekérdezett oszlopokhoz (különösen azokhoz, amelyeket a WHERE, JOIN és ORDER BY záradékokban használsz). Kerüld a SELECT *-et, helyette explicit módon csak a szükséges mezőket kérd le a attributes opció használatával.
Ha a Sequelize nem hatékony lekérdezéseket generál felesleges csatlakozásokkal, írja át a lekérdezést nyers SQL használatával. Nagy jelentések vagy elemzési lekérdezések esetén bontsa őket kisebb lépésekre, vagy használjon gyorsítótárazó eszközöket, például a Redis-t az ismétlődő eredmények tárolására.
6. Holtpontok és párhuzamossági hibák
Probléma: Olyan hibákat kap, mint a Deadlock found when trying to get lock; try restarting transaction, különösen nagy terhelés alatt.
Hogyan diagnosztizáljuk:
Ellenőrizze az InnoDB állapotát a MySQL-ben, hogy azonosítsa, mely lekérdezések vagy táblák vettek részt:
SHOW ENGINE INNODB STATUS\GEz a kimenet részletes információkat tartalmaz a legutóbbi zárolási és blokkolási helyzetekről. Beállíthatja az általános vagy tranzakciós naplókat is, hogy áttekintse azokat a lekérdezéseket, amelyek a probléma kialakulásához vezettek.
Hogyan javítsuk:
A holtpontok akkor fordulnak elő, amikor két vagy több tranzakció egymás zárolására vár. Minimalizálásuk érdekében:
Tartsd a tranzakciókat a lehető legrövidebbre. Ne hívj külső szolgáltatásokat, és ne végezz nagy számítási igényű műveleteket, miközben zárolást tartasz.
Mindig ugyanabban a sorrendben érje el a táblákat és sorokat a tranzakciók során, hogy elkerülje a körkörös várakozást.
Ismétlődő holtpontok esetén valósítson meg egy egyszerű újrapróbálkozási mechanizmust exponenciális visszaeséssel:
async function runWithRetry(fn, retries = 3) { for (let i = 0; i < retries; i++) { try { return await fn(); } catch (err) { if (isDeadlockError(err) && i < retries - 1) { await sleep(100 * (i + 1)); continue; } throw err; } } }A sor szintű zárolásokat (
SELECT ... FOR UPDATE) csak akkor használd, ha szükséges, és engedd fel azokat gyorsan.Ossza szét a nagy tranzakciókat kisebb tételekre a versengés csökkentése érdekében.
Szükség esetén állítsa be a tranzakciós elszigeteltségi szinteket, de csak miután megerősítette, hogy ez nem befolyásolja az adatok konzisztenciáját.
Teljesítmény optimalizálási tippek
A teljesítményproblémák gyakran a nem hatékony lekérdezésekből, hiányzó indexekből vagy gyenge kapcsolatkezelésből erednek. Íme néhány gyakorlati tipp a Sequelize teljesítményének javítására anélkül, hogy feláldoznánk az átláthatóságot vagy a karbantarthatóságot.
1. Lekérdezések optimalizálása
Írj olyan lekérdezéseket, amelyek csak a szükséges adatokat kérik le. A felesleges adatok lekérése növeli a memóriahasználatot és lassítja a válaszidőt. A mezők korlátozásához használd a attributes elemet:
const users = await User.findAll({ attributes: ['id', 'name'] });Mindig használj indexelt oszlopokat a találatok szűrésére, és lehetőség szerint kerüld a széles körű kereséseket, például a LIKE '%term%' kifejezést.
2. Használja hatékonyan a mutatókat
A indexek gyorsabbá teszik a keresést, de lassíthatják az írási műveleteket. Csak ott adj hozzá indexeket, ahol mérhető előnyt nyújtanak. Elemezd a lekérdezések teljesítményét a MySQL EXPLAIN segítségével, hogy az index hozzáadása előtti és utáni javulást ellenőrizd:
await queryInterface.addIndex('users', ['email']);3. Hangolja be a kapcsolatkészletet
A kapcsolatpool meghatározza, hogy hány adatbázis-kapcsolatot tart fenn a Sequelize.
- Kis alkalmazásoknál általában 5–10 kapcsolat elegendő.
- Nagy terhelésű rendszerek esetén növelje a pool méretét, és állítsa be az időkorlátokat a kapcsolatcsomópontok elkerülése érdekében. Rendszeresen figyelje a használatot a MySQL
SHOW PROCESSLIST;parancsával.
4. Naplózás és monitorozás engedélyezése
A Sequelize naplózást ideiglenesen kapcsolja be az SQL lekérdezések áttekintéséhez. Használja a MySQL lassú lekérdezés naplót azoknak a lekérdezéseknek az azonosítására, amelyek meghaladják a teljesítményküszöbét. Valós idejű nyomon követéshez integráljon olyan megfigyelő eszközöket, mint a PM2, a New Relic vagy a Datadog a késleltetés és az erőforrás-használat mérésére.
5. Gyakori lekérdezések gyorsítótárazása
Tárolja a gyorsítótárban azokat az adatokat, amelyek ritkán változnak. Olyan eszközök, mint a Redis vagy a Memcached csökkentik az adatbázis-hívásokat és javítják a válaszidőt, különösen olvasás-intenzív munkaterhelések esetén.
6. Eredmények lapozása
A nagy eredményhalmazok jelentős memóriát fogyasztanak. Mindig oldalméret szerint paginálj az API-k lekérdezéseiben:
const users = await User.findAll({ limit: 50, offset: 100 });Az oldaltördelés megőrzi a válaszokat könnyűnek és következetesnek terhelés alatt.
7. Használj nyers lekérdezéseket összetett műveletekhez
Ha a Sequelize absztrakciója egy adott esetben hatástalan SQL-t eredményez, hajts végre egy nyers SQL lekérdezést közvetlenül:
const [results] = await sequelize.query('SELECT name FROM users WHERE active = 1');Használja a nyers lekérdezéseket csak mértékkel, és dokumentálja őket világosan a jövőbeli karbantartás érdekében.
GYIK
1. Mi az a Sequelize a Node.js-ben?
A Sequelize egy objektum-relációs leképező (ORM) a Node.js-hez, amely magas szintű, JavaScript alapú API-t biztosít SQL adatbázisok, például MySQL, PostgreSQL, SQLite és MariaDB kezeléséhez. Ahelyett, hogy minden művelethez nyers SQL-t írnál, modelleket határozol meg, amelyek az adatbázis tábláihoz kapcsolódnak, és a modell metódusait használod rekordok beszúrására, lekérdezésére, frissítésére és törlésére. A Sequelize támogatja az asszociációkat (a modellek közötti kapcsolatokat), tranzakciókat, migrációkat és nyers lekérdezéseket is, amikor közvetlen SQL-re van szükség.
2. Hogyan csatlakoztassam a Sequelize-t a MySQL-hez?
A Sequelize MySQL-hez való csatlakoztatásához hozz létre egy Sequelize példányt az adatbázis hitelesítő adataiddal és beállításaiddal. Egy Node.js fájlban importáld a Sequelize-t, opcionálisan töltsd be a környezeti változókat, majd példányosítsd az adatbázis neve, felhasználóneve, jelszava és a host/dialekt beállítások megadásával. Például:
require('dotenv').config();
const { Sequelize } = require('sequelize');
const sequelize = new Sequelize(
process.env.DB_NAME,
process.env.DB_USER,
process.env.DB_PASSWORD,
{
host: process.env.DB_HOST || 'localhost',
dialect: 'mysql'
}
);
await sequelize.authenticate();
console.log('Connected to the database successfully!');Mindig tartsd a hitelesítő adatokat a forráskódtól távol (például egy .env fájlban vagy egy titkok kezelőben).
3. Hogyan hozhatok létre modelleket és szinkronizálhatom őket a Sequelize-ben?
A Sequelize-ben a modellek táblákat képviselnek. Ezeket a sequelize.define() segítségével vagy a Model osztály kiterjesztésével definiálhatod. Ezután szinkronizálhatod őket az adatbázisoddal, így a Sequelize automatikusan létrehozza a táblákat (nagyszerű a fejlesztéshez). Íme egy kis példa:
const { DataTypes } = require('sequelize');
const Book = sequelize.define('Book', {
title: { type: DataTypes.STRING, allowNull: false },
author: { type: DataTypes.STRING, allowNull: false },
releaseDate: DataTypes.DATEONLY
});
// Create the table if it does not exist
await sequelize.sync();A termelési környezetekben jobb a migrációkat használni, így verziókövetést biztosíthatsz a séma változásai felett.
4. Hogyan használhatom a Sequelize-t az Express-szel?
Egy Express alkalmazásban inicializáld a Sequelize-t egy külön fájlban (például db.js), exportáld a csatlakoztatott példányt és a modelleket, majd importáld őket oda, ahol szükséged van rájuk a route handler-ekben vagy controller-ekben. Használj async/await-et a route handler-ekben a Sequelize modellek metódusainak meghívásához, és kezeld a hibákat try/catch segítségével vagy egy hibakezelő middleware-ben. Így néz ez ki a gyakorlatban:
// db.js
const sequelize = new Sequelize(...);
const User = sequelize.define(...);
module.exports = { sequelize, User };
// app.js
const { User } = require('./db');
app.get('/users', async (req, res) => {
const users = await User.findAll();
res.json(users);
});Győződj meg róla, hogy lefuttatod a migrációkat, vagy meghívod a sequelize.sync()-t, mielőtt elindítanád az Express szerveredet, hogy az adatbázis tábláid létezzenek, amikor érkeznek a kérések.
5. Mi a különbség a Sequelize és a nyers SQL lekérdezések között?
A Sequelize lehetővé teszi, hogy adatbázis- logikát JavaScriptben írj, míg a nyers SQL azt jelenti, hogy közvetlenül SQL utasításokat írsz. A Sequelize tisztábbá és könnyebben karbantarthatóvá teszi a kódodat, mivel egyszer definiálhatod a modelleket és a kapcsolatokat, és ezeket az alkalmazásodban bárhol használhatod. A nyers SQL nagyobb ellenőrzést ad, és nagyon összetett lekérdezések esetén néha gyorsabb is lehet.
Röviden, a mindennapi feladatokhoz használd a Sequelize-t, és nyers SQL-t akkor, ha teljesítményt kell optimalizálnod, vagy valami olyasmit kell futtatnod, amit a Sequelize nehezen tud kifejezni.
6. Hogyan definiálhatok kapcsolatokat a Sequelize-ban?
A Sequelize megkönnyíti a táblák közötti kapcsolatok leírását. Egyszerű módszerekkel, mint a hasOne, hasMany és belongsToMany, beállíthatók egy-egy, egy-több vagy több-több kapcsolatok. Például:
// One to one
User.hasOne(Profile);
Profile.belongsTo(User);
// One to many
Author.hasMany(Book);
Book.belongsTo(Author);
// Many to many
Student.belongsToMany(Course, { through: 'StudentCourse' });
Course.belongsToMany(Student, { through: 'StudentCourse' });Miután meghatározta, használhatja a include-t a lekérdezéseiben, hogy automatikusan betöltse a kapcsolódó adatokat.
7. Hogyan kezeljem a migrációkat és az adatbázis-sémaváltozásokat?
Fejlesztés közben a sequelize.sync() használatával gyorsan létrehozhatsz táblákat. De éles környezetben mindig migrációkat kell használnod. A migrációk verziózott fájlok, amelyek leírják, hogyan változik az adatbázis-séma az idő múlásával, hasonlóan ahhoz, ahogy a Git commitok követik a kódváltozásokat.
A Sequelize CLI segítségével létrehozhatsz egy migrációt:
npx sequelize-cli migration:generate --name add-users-tableMinden migrációnak van up és down metódusa, az egyik a változtatás alkalmazására, a másik annak visszavonására szolgál. A migrációidat futtasd a következőképpen:
npx sequelize-cli db:migrateÍgy mindenki a csapatodban (és minden telepítésnél) ugyanazt az adatbázis-struktúrát használja.
A gyors kísérletekhez használd a sequelize.sync()-t, de éles alkalmazás esetén tartsd magad a migrációkhoz, mert azok biztonságosabbak, visszafordíthatók és könnyebb nyomon követni őket.
Következtetés
Ebben az útmutatóban a Sequelize-t állítod be Node.js-sel és MySQL-lel, hogy modelleken, kapcsolatokon és migrációkon keresztül kezeld az adatokat. Emellett biztonságossá tetted az adatbázis hitelesítő adataidat környezeti változókkal, és megismerkedtél a hibaelhárítási és teljesítmény-optimalizálási legjobb gyakorlatokkal is.
Ezekkel a lépésekkel most már szilárd alapod van biztonságos, hatékony Node.js alkalmazások építéséhez és karbantartásához, amelyek adatkezeléshez a Sequelize-t és a MySQL-t használják.
A Sequelize-ről további információkért tekintse meg a termék dokumentációját. További hasonló Node.js oktatóanyagokért nézze meg a következő cikkeket:
- Hogyan állítsunk be egy GraphQL szervert Node.js-ben Apollo Server és Sequelize segítségével
- Hogyan valósítsunk meg gyorsítótárazást Node.js-ben Redis használatával
- Hogyan hozzunk létre webkiszolgálót Node.js-ben az HTTP modul segítségével
Köszönjük, hogy a Linux-Console.net közösséggel tanultál.