Kuinka käyttää Sequelizea Node.js:n ja MySQL:n kanssa
Kirjailija valitsi Open Internet/Free Speech Fund -rahaston vastaanottamaan lahjoituksen osana Write for Donations -ohjelmaa.
Johdanto
Sequelize on Node.js-pohjainen objektisuhdekartoitin (ORM), joka tekee MySQL-, MariaDB-, SQLite-, PostgreSQL-tietokantojen ja monien muiden kanssa työskentelystä helppoa. Objektisuhdekartoitin suorittaa toimintoja, kuten tietueiden käsittelyä tietokannassa esittämällä tiedot objekteina. Sequelizella on tehokas migraatiomekanismi, joka voi muuntaa olemassa olevat tietokantarakenteet uusiksi versioiksi. Kaiken kaikkiaan Sequelize tarjoaa erinomaisen tuen tietokantojen synkronoinnille, eager-lataukselle, assosiaatioille, transaktioille ja tietokantamigraatioille samalla, kun se vähentää kehitysaikaa ja estää SQL-injektioita.
Tässä opetusohjelmassa asennat ja konfiguroit Sequelizea MySQL:n kanssa paikallisessa kehitysympäristössäsi. Seuraavaksi käytät Sequelizea tietokantojen ja mallien luomiseen sekä suoritat insert, select ja delete -toiminnot. Sen jälkeen luot Sequelize-suhteita one-to-one, one-to-many ja many-to-many -suhteille. Lopuksi luot Sequelize-raakakyselyitä taulukkojen ja objektien korvaamiseen. Näiden perusteiden lisäksi opetusohjelma käsittelee myös tietokannan turvallista konfigurointia ympäristömuuttujien avulla, skeemamuutosten hallintaa turvallisesti migraatioiden kautta sekä parhaimpia käytäntöjä ongelmien ratkaisussa ja suorituskyvyn optimoinnissa.
Ota käyttöön frontend-sovelluksesi GitHubista käyttämällä Linux-Console.net App Platformia. Anna Linux-Console.netin huolehtia sovelluksesi skaalaamisesta.
Tärkeimmät asiat:
- Sequelize tarjoaa helpon tavan käyttää MySQL:ää mallien avulla raakaa SQL:ää käyttämättä, mikä tekee tietokantaoperaatioista yksinkertaisempia ja järjestäytyneempiä.
- Tietokantatunnusten tallentaminen ympäristömuuttujiin pitää arkaluontoiset tiedot turvassa ja versionhallinnan ulkopuolella.
- Skeeman päivityksissä migraatioiden käyttö on turvallisempaa kuin luottaminen
sequelize.sync()-metodiin, erityisesti tuotantoympäristöissä. - Sequelize tekee helppoa määritellä yhden suhteen, yhden-moneen ja monta-moneen suhteita mallien välillä.
- Raakoja SQL-kyselyitä voidaan edelleen käyttää, kun tarvitset enemmän hallintaa tai parempaa suorituskykyä monimutkaisissa tietokantaoperaatioissa.
- Yleisimmät Sequelize-ongelmat, kuten yhteysvirheet tai siirtojen virheet, voidaan ratkaista tarkistamalla ympäristömuuttujat, tutkimalla lokitiedostoja ja käyttämällä MySQL-työkaluja, kuten
EXPLAINjaSHOW PROCESSLIST. - Suorituskykyä voidaan parantaa optimoimalla kyselyt, lisäämällä asianmukaiset indeksit, säätämällä yhteyspoolit ja välimuistittamalla usein käytettyjä tietoja.
- Migraatioiden testaaminen, virheenkäsittelyn lisääminen ja tietokannan suorituskyvyn seuranta auttavat pitämään Sequelize-sovellukset luotettavina ja tuotantovalmiina.
Edellytykset
Tämän oppaan suorittamiseen tarvitset:
- Kehitysympäristö, jossa ajetaan Node.js:ää. Ota tämä käyttöön seuraamalla ohjetta 'Kuinka asentaa Node.js ja luoda paikallinen kehitysympäristö' oman käyttöjärjestelmäsi mukaan.
- MySQL asennettuna työympäristöösi. Seuraa MySQL:n asennusopasta omaa ympäristöäsi varten, mukaan lukien vaiheet käyttäjän luomiseksi.
- Tuntemus JavaScriptistä ja MySQL-kyselyistä, joita voit kehittää How To Code in JavaScript -sarjan ja An Introduction to Queries in MySQL -opetusohjelman avulla.
- Peruskäsitys relaatiotietokantojen käsitteistä, jonka löydät oppaasta Understanding Relational Databases.
Tämä opas testattiin Node.js-versiolla v24.11.1 ja npm-versiolla 11.6.2.
Sequelizen asentaminen ja määrittäminen
Tässä vaiheessa asennat Sequelize:n ja luot yhteyden MySQL-tietokantaasi. Tätä varten luot ensin Node.js-sovelluksen. Sitten asennat Sequelize:n, konfiguroit MySQL-tietokannan ja kehität yksinkertaisen sovelluksen.
Sequelizen asentaminen
Aloita luomalla projektikansio. Tässä esimerkissä voit käyttää hello-world. Kun kansio on luotu, siirry kansioon terminaalin avulla:
mkdir hello-world
cd hello-worldLuo sitten esimerkkisovellus Node.js:llä käyttämällä seuraavaa komentoa:
npm initSeuraavaksi sinua pyydetään vastaamaan joihinkin asetuskysymyksiin. Käytä seuraavaa tulostetta konfiguraatiosi varten. Paina ENTER käyttääksesi näytettyä oletusarvoa ja varmista, että pääsisäänkäyntipisteeksi asetetaan server.js. Tämä luo projektirakenteen, jota on helppo ylläpitää.
Tuloste näyttää seuraavalta, ja se täyttää package.json-tiedoston:
{
"name": "hello-world",
"version": "1.0.0",
"description": "",
"main": "server.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}Seuraavaksi luo tyhjä server.js-tiedosto projektikansion sisälle:
touch server.jsKun olet seurannut edellisiä vaiheita, lopullinen kansiorakenteesi näyttää tältä:
hello-world/
├─ package.json
├─ server.jsNyt voit asentaa Sequelizen seuraavalla komennolla:
npm i sequelizeNäiden päivitysten jälkeen package.json-tiedosto näyttää nyt tältä:
{
"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"
}
}Kohdassa dependencies näet nyt Sequelize-riippuvuuden.
Olet perustanut projektin ja asentanut Sequelize:n. Seuraavaksi luot esimerkkitietokannan, johon yhdistät.
Esimerkkitietokannan luominen
Osana vaatimuksia asensit ja konfiguroit MySQL:n, johon kuului käyttäjän luominen. Nyt luot tyhjän tietokannan.
Tehdäksesi sen, sinun tulee ensin kirjautua MySQL-instanssiisi. Jos käytät etäyhteyttä, voit käyttää haluamaasi työkalua. Jos käytät paikallisesti olevaa MySQL-instanssia, voit käyttää seuraavaa komentoa, korvaten your_username MySQL-käyttäjänimelläsi:
mysql -u your_username -p-u on käyttäjätunnus ja -p-valinta annetaan, jos tili on suojattu salasanalla.
MySQL-palvelin pyytää tietokantasi salasanaa. Kirjoita salasanasi ja paina ENTER.
Kun olet kirjautunut sisään, luo tietokanta nimeltä hello_world_db seuraavalla komennolla:
CREATE DATABASE hello_world_db;Varmistaaksesi, että olet luonut tietokannan onnistuneesti, voit käyttää tätä komentoa:
SHOW DATABASES;Tulosteesi tulee olemaan samanlainen kuin tämä:
+--------------------+
| Database |
+--------------------+
| hello_world_db |
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+Kun näyte-tietokanta on luotu, katkaise yhteys MySQL-palvelimeen:
mysql> QUITNyt sinun täytyy asentaa manuaalinen ajuri valitsemallesi tietokannalle. Koska Sequelize tarjoaa vain ORM-ominaisuuksia, siihen ei sisälly sisäänrakennettuja tietokanta-ajureita. Siksi sinun täytyy asentaa ajurit mieltymyksesi mukaan. Tämän tekemiseksi siirry projektihakemistoon terminaalin avulla ja asenna MySQL-ajuri projektiin seuraavalla komennolla:
npm install --save mysql2Tässä tapauksessa käytät MySQL-ohjainta.
Huomautus: Koska tässä opetusohjelmassa käytetään MySQL:ää tietokantana, käytät siihen tarkoitettua ajuria. Riippuen tietokannastasi, voit asentaa ajurin manuaalisesti seuraavasti:
npm install --save pg pg-hstore # Postgresnpm install --save mysql2npm install --save mariadbnpm install --save sqlite3npm install --save tedious # Microsoft SQL Server
Nyt kun sinulla on esimerkkitietokanta, voit luoda ensimmäisen Sequelize-sovelluksesi tietokantayhteydellä.
Yhdistetään MySQL-tietokantaan
Tässä osassa yhdistät Node.js-sovelluksen MySQL-tietokantaan käyttämällä Sequelizea.
Yhteyden muodostamiseksi tietokantaan, avaa server.js muokattavaksi käyttämällä nano-editoria tai haluamaasi koodieditoria:
nano server.jsTässä luot tietokantayhteyden sovellukseesi käyttämällä Sequelize-instanssia. new Sequelize()-metodissa anna MySQL-palvelimen parametrit ja tietokannan tunnistetiedot seuraavasti, korvaten DATABASE_USERNAME ja DATABASE_PASSWORD oman MySQL-käyttäjäsi tunnistetiedoilla:
const Sequelize = require("sequelize");
const sequelize = new Sequelize(
'hello_world_db',
'DATABASE_USERNAME',
'DATABASE_PASSWORD',
{
host: 'DATABASE_HOST',
dialect: 'mysql'
}
);host on paikka, jossa MySQL-palvelin isännöidään, joten sinun täytyy antaa palvelimen URL-osoite tai IP-osoite. Jos käytät paikallisesti asennettua MySQL-palvelinta, voit korvata DATABASE_HOST arvolla localhost tai 127.0.0.1.
Vastaavasti, jos käytät etäpalvelinta, varmista, että korvaat tietokantayhteyden tiedot asianmukaisilla etäpalvelimen tiedoilla.
Huomautus: Jos käytät jotain muuta tietokantapalvelinohjelmistoa, voit korvata dialect-parametrin sen mukaisesti.
Seuraavaksi kutsu lupaukseen perustuvaa authenticate()-metodia luodaksesi tietokantayhteyden sovellukseen. Tee tämä lisäämällä seuraava koodilohko server.js-tiedostoosi:
...
sequelize.authenticate().then(() => {
console.log('Connection has been established successfully.');
}).catch((error) => {
console.error('Unable to connect to the database: ', error);
});authenticate()-metodia käytetään yhdistämään tietokantaan ja testaamaan, ovatko annetut tunnistetiedot oikein. Tässä tietokantayhteys on oletuksena auki, ja samaa yhteyttä voidaan käyttää kaikkiin kyselyihin. Kun sinun täytyy sulkea yhteys, kutsu sequelize.close()-metodia tämän authenticate()-kutsun jälkeen. Lisätietoja Sequelizeista saat heidän aloitusoppaan kautta.
Suurin osa Sequelize:n tarjoamista menetelmistä on asynkronisia. Tämä tarkoittaa, että voit suorittaa prosesseja sovelluksessasi samalla kun asynkroninen koodilohko on käynnissä. Lisäksi onnistuneen asynkronisen koodilohkon suorittamisen jälkeen se palauttaa promise-olion, joka on prosessin lopussa palautettu arvo. Siksi asynkronisissa koodilohkoissa voit käyttää then(), catch() ja finally() käsittelemään palautettua dataa.
Tässä vaiheessa server.js-tiedosto näyttää seuraavalta:
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);
});Tallenna ja sulje tiedostosi.
Projektihakemistossa suorita server.js-sovellus ajamalla seuraava komento:
node server.jsLähtötuloksesi näyttää tältä:
Connection has been established successfully!Olet luonut tietokantayhteyden onnistuneesti.
Tässä vaiheessa asensit Sequelizen, loit esimerkkitietokannan ja käytit Sequelizeä yhdistääksesi tietokantaan. Seuraavaksi työskentelet Sequelizen mallien kanssa.
Tietokantataulun luominen Sequelizella
Nyt kun olet luonut esimerkkitietokannan MySQL:ssä, voit käyttää Sequelizeä taulukon luomiseen ja sen täyttämiseen tiedoilla. Sequelizessa tietokantatauluja kutsutaan malleiksi. Malli on abstraktio, joka edustaa tietokannan taulukkoa. Mallit määrittelevät Sequelizelle useita asioita, kuten taulun nimen, saraketiedot ja tietotyypit. Tässä vaiheessa luot Sequelize-mallin kirjatiedoille.
Aloita luomalla uusi tiedosto nimeltä book.model.js projektihakemistoon:
nano book.model.jsSamankaltaisesti kuin edellisessä vaiheessa, lisää Sequelize-koodi tietokannan alustamista varten ja tuo tiedoston yläosaan uusi DataTypes-import:
const { Sequelize, DataTypes } = require("sequelize");Sequelize sisältää monia sisäänrakennettuja tietotyyppejä. Näihin tietotyyppeihin pääsemiseksi lisäät tuonnin DataTypes varten. Tämä opas viittaa joihinkin usein käytettyihin tietotyyppeihin, kuten STRING, INTEGER ja DATEONLY. Lisätietoja muista tuetuista tietotyypeistä löydät virallisesta Sequelize-dokumentaatiosta.
Lisää sitten aiemmin käyttämäsi rivit MySQL-tietokantaasi yhdistämiseksi, päivittäen MySQL-tunnuksesi vastaavasti:
...
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);
});Seuraavaksi luot mallin nimeltä books, joka sisältää title, author, release_date ja subject -tunnuksen. Tee tämä käyttämällä sequelize.define()-metodia seuraavasti:
...
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.define()-metodi määrittelee uuden mallin, joka edustaa taulukkoa tietokannassa. Tämä koodilohko luo taulukon nimeltä books ja tallentaa kirjatiedot kenttien title, author, release_date ja subject mukaan.
Tässä koodissa allowNull osoittaa, että mallin sarakkeen arvo ei voi olla null. Samoin, jos sinun tarvitsee asettaa tällainen arvo, voit käyttää defaultValue: "value".
Seuraavaksi lisäät book-mallin tietokantaasi. Teet tämän käyttämällä sync()-metodia seuraavasti:
...
sequelize.sync().then(() => {
console.log('Book table created successfully!');
}).catch((error) => {
console.error('Unable to create table : ', error);
});Metodissa sync() pyydät Sequelizea tekemään muutamia asioita tietokannalle. Tämän kutsun avulla Sequelize suorittaa automaattisesti SQL-kyselyn tietokantaan ja luo taulun, tulostaen viestin Book table created successfully!.
Kuten mainittu, sync()-metodi on lupausta (promise) käyttävä metodi, mikä tarkoittaa, että se voi myös käsitellä virheitä. Tässä koodilohkossa tarkistat, onko taulu luotu onnistuneesti. Jos ei, se palauttaa virheen catch-metodin kautta ja tulostaa sen tulosteeseen.
Huomautus: Voit hallita mallin synkronointia välittämällä force-parametreja pakottaaksesi uuden taulukon luomisen, jos sitä ei ole olemassa, tai käyttää olemassa olevaa. Tässä on joitakin esimerkkejä, jotka saattavat olla hyödyllisiä työskennellessäsi Sequelizen kanssa:
model.sync(): Tämä luo taulun, jos sitä ei vielä ole.model.sync({ force: true }): Tämä luo taulun poistamalla olemassa olevan taulun, jos sellainen on jo olemassa.
Lopullinen koodi näyttää tältä:
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);
});Tallenna ja sulje tiedostosi.
Suorita sovelluksesi käyttämällä seuraavaa komentoa:
node book.model.jsSaat seuraavan tulosteen komentorivilläsi:
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!Tulosteessa näet, että palautuslokissa on viesti Book table created successfully!. Voit tarkistaa tämän tarkistamalla tietokantasi ja nähdäksesi uuden books-taulun, joka on luotu hello_world_db-tietokantaan.
Varmistaaksesi uuden taulun luomisen, kirjaudu MySQL-instanssiisi:
mysql -u YOUR_USERNAME -pSyöttämisen jälkeen salasanasi, siirry esimerkkitietokantaan:
USE hello_world_db;Ja sitten suorita komento näyttääksesi taulukot:
SHOW TABLES;Tulosteesi tulee olemaan samanlainen kuin tämä:
+---------------------------+
| Tables_in_hello_world_db |
+---------------------------+
| books |
+---------------------------+
1 row in set (0.00 sec)Lopuksi irrota yhteys MySQL-palvelimeen:
mysql> QUITOlet vahvistanut, että book-mallin luominen onnistui. Tämän prosessin avulla voit luoda minkä tahansa määrän malleja noudattamalla samaa menettelyä.
Tässä vaiheessa loit mallin tietokantaan ja aloittit työskentelyn mallin kanssa käyttämällä sisäänrakennettuja menetelmiä. Käytit myös Sequelize:n tukemia tietotyyppejä määritelläksesi mallisi. Seuraavaksi työskentelet perusmallikyselyiden kanssa.
Sequelizella tietokantakyselyjen tekeminen
Tässä vaiheessa käytät Sequelizen sisäänrakennettuja kyselyjä lisäykseen, valintaan, valintaan ehtolauseilla ja poistamiseen.
Uuden tietueen lisääminen
Edellisessä vaiheessa loit tietokannan sisälle book-mallin. Tässä osassa lisäät tietoja tähän malliin.
Aloittaaksesi kopioi edellisessä vaiheessa luodun book.model.js-tiedoston sisältö. Luo uusi tiedosto nimeltä book.controller.js käsittelemään kyselylogiikkaa. Lisää book.model.js-tiedoston koodi book.controller.js-tiedostoon.
Tiedostossa book.controller.js etsi sync()-metodi. Lisää sync()-metodiin seuraavat korostetut rivit:
...
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);
});Tässä lisäät uuden kirjatietueen jo luomaasi books-malliin käyttäen sync()-metodia, joka tukee uusien tietueiden lisäämistä aiemmin luotuihin malleihin. Kun sync()-metodi suoritetaan onnistuneesti, se ajaa then()-metodin. then()-metodin sisällä kutsut create()-metodia lisätäksesi uudet tietueet malliin.
Käytät create()-metodia välittääksesi tiedot, jotka haluat lisätä tietokantaan objektina. Korostettu koodiosio lisää uuden merkinnän olemassa olevaan books-tauluusi. Tässä esimerkissä lisäät Clean Code -teoksen, jonka on kirjoittanut Robert Cecil Martin, ja joka on luokiteltu subject-ID:llä 3. Voit käyttää samaa koodia, päivitettynä muiden kirjojen tiedoilla, lisätäksesi uusia tietueita tietokantaasi.
Tallenna ja sulje tiedosto.
Suorita sovellus käyttämällä seuraavaa komentoa:
node book.controller.jsTulosteesi näyttää suunnilleen seuraavalta:
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,
...
}Lisäsit uuden tietueen luomaasi malliin tietokannassa. Voit jatkaa useiden tietueiden lisäämistä käyttämällä samaa prosessia.
Kaikkien tietueiden valinta
Tässä osiossa valitset ja haet kaikki kirjatietueet tietokannasta käyttämällä findAll()-metodia. Tee se avaamalla ensin book.controller.js ja poistamalla aiempi Book.create()-metodi. Lisää sync()-metodiin Book.findAll()-metodi seuraavasti:
...
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);
});
...Tallenna ja sulje tiedosto.
Seuraavaksi suorita sovellus uudelleen käyttämällä seuraavaa komentoa:
node book.controller.jsTulosteesi näyttää suunnilleen seuraavalta:
[
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
},
...
]Tuloste sisältää kaikki kirjatiedot taulukko-objektina. Käytit onnistuneesti Sequelize findAll()-metodia palauttaaksesi kaikki kirjatiedot tietokannasta.
Valitseminen where-lauseella
Tässä osiossa valitset arvoja ehtojen avulla käyttäen where-lauseketta. where-lauseketta käytetään määrittämään ehto tietoja haettaessa. Tässä opetusohjelmassa haet kirjan tietokannasta tietyn tietueen tunnuksella käyttäen findOne()-metodia.
Tätä varten avaa book.controller.js muokattavaksi, poista findAll()-metodi ja lisää seuraavat rivit:
...
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);
});Tässä valitset tietokannasta tietyn kirjatietueen käyttämällä findOne()-metodia yhdessä where-option kanssa. Tässä esimerkissä haetaan kirjatiedot, joiden id on yhtä kuin 1.
Tallenna ja sulje tiedosto.
Seuraavaksi suorita sovellus:
node book.controller.jsTulosteesi näyttää suunnilleen seuraavalta:
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
},
...
}Olet onnistuneesti käyttänyt where-lauseita saadaksesi tietoja Sequelize-malleista. Voit käyttää where-lausetta tietokantasovelluksessa kerätäksesi ehdollisia tietoja.
Tietueen poistaminen
Tietokantamallista tietyn tietueen poistamiseksi käytät destroy()-metodia yhdessä where-valinnan kanssa. Tee näin avaamalla book.controller.js, poistamalla findOne()-metodi ja lisäämällä seuraavat korostetut rivit:
...
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);
});Tässä voit poistaa kirjatietueen tietokannasta käyttämällä destroy()-metodia where-vaihtoehdon kanssa ja antamalla poistettavan kirjan id-arvon. Aiot poistaa kirjatietueen, jonka id on 2.
Tallenna ja sulje tiedosto.
Seuraavaksi suorita sovellus:
node book.controller.jsTulosteesi näyttää seuraavalta:
Successfully deleted record.Tietue on poistettu.
Tässä vaiheessa kokeilit tietokantamalliasi ja mallien kyselyä. Käynnistit tietokannan, loit malleja, lisäsit tietueita, haet tietueita, haet tietueita ehtojen avulla käyttäen where-lausetta ja poistit valittuja tietueita. Tämän Sequelize-tiedon avulla luot nyt Sequelizessa assosiaatioita. Tämän jälkeen pystyt määrittelemään ja työskentelemään erilaisten suhteiden kanssa Sequelize-mallien avulla.
Yhteyksien luominen Sequelizella
Tässä vaiheessa käytät Sequelize:n tukemia vakiintuneita assosiaatiotyyppejä: yksi-yhteen, yksi-moneen ja moneen-moneen assosiaatioita. Käytät esimerkkitietoja opiskelijoista, kursseista ja arvosanatasoista.
Sequelize käyttää assosiaatiotyyppejä seuraaviin tietokantasuhteisiin perustuen:
yksi-yhteen suhde: Yksi-yhteen suhde tarkoittaa, että yhden taulun tietue liittyy täsmälleen yhteen tietueeseen toisessa taulussa. Sequelize:n yhteydessä voit käyttää
belongsTo()jahasOne()-yhteyksiä luodaksesi tämän tyyppisen suhteen.yksi-moneen suhde: Yksi-moneen suhde tarkoittaa, että yhden taulun tietue liittyy useisiin tietueisiin toisessa taulussa. Sequelizella voit käyttää
hasMany()-yhteysmenetelmiä luodaksesi tämän tyyppisen suhteen.moni-moni suhde: Moni-moni -suhde tarkoittaa, että useat tietueet yhdessä taulussa liittyvät useisiin tietueisiin toisessa taulussa. Sequelizessa voit käyttää
belongsToMany()-yhteyksiä luodaksesi tämän tyyppisen suhteen.
Ennen näiden yhdistysten luomista luot ensin uuden tietokannan nimeltä student_db ja lisäät uusia malleja sekä joitakin esimerkkitietoja opiskelijoista, kursseista ja arvosanatasoista.
Tietokannan luomiseksi noudata samaa prosessia kuin kohdassa Asentaminen ja Konfigurointi Sequelize: kirjaudu MySQL:ään ja luo tietokanta nimeltä student_db. Kun uusi tietokanta on luotu, kirjaudu ulos MySQL:stä. Seuraavaksi aloitat tietokantayhteyksien luomisen.
Yhden suhteen luominen belongsTo()-metodilla
Tässä osassa luot yhden suhteen kerrallaan käyttäen Sequelize-malleja. Kuvittele, että haluat saada yhden opiskelijan tiedot yhdessä hänen luokkatasonsa kanssa. Koska yhdellä opiskelijalla voi olla vain yksi luokkataso, tämäntyyppinen suhde on yhden suhteen kerrallaan ja voit käyttää belongsTo()-metodia.
Huomautus: belongsTo() ja hasOne() eroavat toisistaan. belongsTo() lisää foreignKey-kentän lähde-tauluun, kun taas hasOne() lisää sen kohde-tauluun. Kummassakin tapauksessa, jos molempia suhteita käytetään samanaikaisesti, se toimii Sequelize:n kaksisuuntaisina yksi-yhteen -suhteina.
belongsTo()-metodi antaa sinun luoda yksittäisen suhteen kahden Sequelize-mallin välille. Tässä esimerkissä käytät Student- ja Grade-malleja.
Luo uusi tiedosto nimeltä one_to_one.js. Kuten teit edellisessä osassa, Yhdistäminen MySQL-tietokantaan, sisällytä tiedoston alkuun rivit tietokantayhteyden luomiseksi ja MySQL-käyttäjäsi todennusta varten. Muista päivittää MySQL-tunnistetiedot tarvittaessa:
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);
});Tässä osiossa luot kolme mallia uuteen student_db-tietokantaan: Student, Grade ja Course. Aloitat luomalla Student- ja Grade-mallit. Myöhemmin tässä vaiheessa luot Courses-mallin.
Lisää Student-mallille seuraava koodilohko tiedostoon one_to_one.js:
...
const Student = sequelize.define("students", {
student_id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: DataTypes.STRING,
allowNull: false
}
});Tässä opiskelijamallissa on kaksi saraketta: student_id ja name.
Seuraavaksi lisää koodilohko Grade-mallille:
...
const Grade = sequelize.define("grades", {
grade: {
type: DataTypes.INTEGER,
allowNull: false
}
});Grade-malli sisältää sarakkeen grade.
Yhteyksien esittämiseksi sinun täytyy lisätä esimerkkitietoja tietokantaan. Tätä varten käytät bulk()-metodia. Sen sijaan, että lisäisit tietoja riveittäin yksi kerrallaan, bulkCreate()-metodi mahdollistaa useiden rivien lisäämisen tietokantamalleihisi kerralla.
Joten nyt tuo Grade- ja Student-tiedot niiden vastaaviin malleihin tietokantaan seuraavasti:
...
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);
});Tässä annat esimerkkitietoja ja lisäät tiedot Student- ja Grade-malleihin. Kun tietokanta, mallit ja esimerkkitiedot ovat valmiina, voit luoda assosiaatiot.
Lisää tiedostossa one-to-one.js seuraava rivi student_data-lohkon alapuolelle:
...
Student.belongsTo(Grade);Seuraavaksi sinun täytyy tarkistaa, toimiiko yhdistys oikein. Voit tehdä sen hakemalla kaikkien opiskelijoiden tiedot ja niiden luokka-asteet käyttämällä include-parametria findAll()-metodin sisällä.
Koska sinun täytyy saada opiskelijan arvosanatason, lähetät Grade mallina. Lisää sequelize.sync() -metodissa korostetut rivit seuraavasti:
...
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);
});Koko koodi näyttää seuraavalta:
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);
});Tallenna ja sulje tiedostosi.
Suorita tiedosto käyttämällä seuraavaa komentoa:
node one_to_one.jsTuloste tulee olemaan pitkä, ja näet kaikkien opiskelijoiden tiedot arvosanatasojen kanssa. Tässä on ote tulosteesta, joka näyttää opiskelijatiedot:
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:
...Riippuen käyttämistäsi komentorivityökaluista, tuloste saattaa näkyä laajennettuna näkymänä tai ei. Jos se on laajennettu näkymä, se tulostaa laajennetun grade-objektin tulosteena.
Tässä osiossa loit yhden suhteen yhdelle -tyyppisen suhteen käyttämällä Student.belongsTo(Grade); -metodia ja sait yksityiskohdat luomasi assosiaation mukaan.
Yhden ja monen välisen suhteen luominen käyttäen hasMany()
Tässä osiossa luot yksi-moneen -suhteen käyttämällä Sequelize-malleja. Kuvittele, että haluat saada kaikki valitun luokka-asteen oppilaat. Koska yhdellä tietyn luokan tasolla voi olla useita oppilaita, tämä on yksi-moneen -suhde.
Aloittaaksesi kopioi one_to_one.js-tiedoston sisältö uuteen tiedostoon nimeltä one_to_many.js. Poista one_to_many.js-tiedostosta rivit student_data-lohkon jälkeen. one_to_many.js-tiedostosi näyttää tältä:
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}
]Kun student_data-lohko on valmis, käytä hasMany()-metodia luodaksesi uuden suhteen:
...
Grade.hasMany(Student)hasMany()-metodi mahdollistaa yhden-moneen-suhteen luomisen kahden Sequelize-mallin välille. Tässä käytät Grade- ja Student-malleja.
Seuraavaksi lisää sequelize.sync()-metodi yhdessä findAll()-metodin kanssa hasMany()-rivin alle:
...
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);
});Tässä yrität päästä käsiksi kaikkiin tietyn luokan oppilaisiin—tässä tapauksessa kaikkiin 9. luokan oppilaisiin. Lisäsit myös Student-mallin include-vaihtoehtoon.
Tässä on koko koodi:
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);
});Tallenna ja sulje tiedostosi.
Suorita tiedosto seuraavalla komennolla:
node one_to_many.jsTuloste näyttää seuraavanlaiselta. Se tulee olemaan melko pitkä, mutta kaikki 9. luokan opiskelijat palautetaan seuraavasti:
[ 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 },
...Tässä osiossa loit yksi-moneen -suhteen käyttämällä Grade.hasMany(Student); -metodikutsua. Tulosteessa haettiin tiedot luomasi assosiaation mukaisesti.
Moni-moni-suhteiden luominen käyttämällä belongsToMany()
Tässä osiossa luot monesta moneen -suhteita käyttämällä Sequelize-malleja. Esimerkiksi kuvittele tilanne, jossa opiskelijat ovat ilmoittautuneet kursseille. Yksi opiskelija voi ilmoittautua monille kursseille ja yhdellä kurssilla voi olla monia opiskelijoita. Tämä on monesta moneen -suhde. Toteuttaaksesi tämän Sequelizeä käyttäen, käytät malleja Student, Course ja StudentCourse yhdessä belongsToMany()-metodin kanssa.
Aloittaaksesi luo tiedosto nimeltä many_to_many.js ja lisää tietokannan alustus- ja todennuskoodilohkot seuraavasti. (Voit käyttää uudelleen koodilohkoja edellisestä one_to_many.js esimerkistä.) Muista päivittää korostetut tietokantayhteyden arvot tarpeen mukaan.
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);
});Seuraavaksi luot tietokantamallit monen-moneen-suhteille: Student ja Course. Sen jälkeen lisäät näihin malleihin joitakin esimerkkitietoja.
...
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},
]Tässä luot Student ja Course -mallit ja annat joitakin esimerkkitietoja. Asetat myös courseID:n, jota käytät opiskelijoiden hakemiseen tämän suhteen perusteella.
Lopuksi määrittelit uuden mallin nimeltä StudentCourse, joka hallinnoi tietoa suhteesta Student- ja Course-mallien välillä. Tässä esimerkissä studentId 1 on ilmoittautunut courseId 1 ja courseId 2 kursseille.
Olet suorittanut tietokannan alustuksen ja lisännyt siihen esimerkkitietoja. Seuraavaksi luo monta-moneen -suhteet käyttämällä belongsToMany()-metodia seuraavasti:
...
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})Sisällä belongsToMany()-metodissa voit välittää through-asetuksen mallin nimenä konfiguraatioasetuksena. Tässä tapauksessa se on StudentCourse. Tämä on taulu, joka hallinnoi monesta moneen -suhteita.
Lopuksi voit tarkistaa, toimiiko yhdistäminen oikein hakemalla kaikki kurssitiedot niihin liittyvine opiskelijoineen. Teet sen välittämällä include-parametrin findAll()-metodin sisällä. Lisää seuraavat rivit tiedostoon many_to_many.js:
...
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);
});Koko koodi näyttää seuraavalta:
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);
});Tallenna ja sulje tiedosto.
Suorita tiedosto käyttämällä seuraavaa komentoa:
node many_to_many.jsTuloste tulee olemaan pitkä, mutta se näyttää jotakuinkin tältä:
[ 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:
...Kuten voit nähdä tässä tulosteessa, kurssit, joihin liittyi opiskelijoita, haettiin. courses-lohkon sisällä näet erilliset id-arvot, jotka osoittavat jokaisen kurssin. Esimerkiksi id: 1 on yhteydessä course_name: Science -kurssiin, eli Science-luokkaan, kun taas id: 2 on Maths-luokka, ja niin edelleen.
Tietokannassa voit nähdä kolme luotua taulukkoa, joissa on lisäämäsi esimerkkitiedot.
Tässä vaiheessa käytit Sequelizea luodaksesi yksi-yhteen-, yksi-moni- ja moni-moni -yhteyksiä. Seuraavaksi työskentelet suoran kyselyjen kanssa.
Työskentely raakatietokyselyjen kanssa
Tässä vaiheessa työskentelet raakatietokantakyselyjen kanssa Sequelizessa. Aiemmissa vaiheissa käytit Sequelizen sisäänrakennettuja metodeja, kuten insert() ja findAll(), tietojen lisäämiseen ja hakemiseen tietokannasta. Olet ehkä huomannut, että näillä metodeilla on tietty kaava kyselyjen kirjoittamiseen. Raakatietokantakyselyjen avulla sinun ei kuitenkaan tarvitse huolehtia Sequelizen sisäänrakennetuista metodeista ja kaavoista. Hyödyntämällä SQL-kyselytietämystäsi voit suorittaa erilaisia kyselyjä Sequelizessa yksinkertaisista monimutkaisempiin.
Tässä on esimerkki raakakyselyistä, jotka suorittavat toiminnon, jossa valitaan kaikki arvot tietystä taulusta, poistetaan valitut arvot ehdon mukaan ja päivitetään taulu annetuilla arvoilla.
SELECT * FROM table_name;
DELETE FROM table_name WHERE condition;
UPDATE table_name SET y = 42 WHERE x = 12;Sequelizessa raakakyselyjä voidaan käyttää pääasiassa kahdella menetelmällä: taulukon korvaus ja objektin korvaus. Kun välität arvoja SQL-kyselyyn, voit käyttää korvaukseen joko taulukkoa tai objektia.
Ennen kuin kirjoitat raakakyselyn, sinun on ensin syötettävä opiskelijatietoja esimerkkitietokantaan. Seuraamalla edellistä osiota, Esimerkkitietokannan luominen, kirjaudu MySQL:ään, luo tietokanta nimeltä sample_student_db ja kirjaudu ulos MySQL:stä.
Seuraavaksi lisäät hieman raakadataa aloittaaksesi työskentelyn raaka kyselyiden kanssa. Luo uusi tiedosto nimeltä add_student_records.js ja lisää seuraavat koodilohkot, jotka sisältävät aiemmin käsitellyt Sequelize-menetelmät authenticate(), sync() ja 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);
});Tässä käynnistät tietokantayhteyden, luot mallin ja lisäät muutamia opiskelijatietueita uuteen tietokantaan.
Tallenna ja sulje tiedosto.
Seuraavaksi suorita tämä skripti käyttämällä seuraavaa komentoa:
node add_student_records.jsTuloste tulee olemaan jotain seuraavanlaista. Se tulee olemaan varsin pitkä, mutta kaikki syöttämäsi opiskelijatiedot palautetaan seuraavasti. Huomaa, että koska student_id on automaattisesti luotu UUID (Universally Unique Identifier) -arvo, se on käyttäjästä riippuen erilainen.
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
},
…Seuraavassa osiossa sovellat raakakyselyitä käyttäen yhtä yllä olevan koodilohkon student_id-tuloksista. Kopioi se ylös, jotta sinulla on se seuraavia osioita varten, joissa käytät query()-metodia taulukoiden ja objektien korvaamiseen.
Taulukon korvaaminen
Tässä osiossa käytät query()-metodia taulukon korvaukseen. Tämän menetelmän avulla Sequelize voi suorittaa raakaa SQL-kyselyä tai valmiiksi valmisteltuja SQL-kyselyjä.
Aloittaaksesi kopioi Vaiheessa 1 luodun server.js-tiedoston sisältö, sillä se sisältää Sequelize()-metodin kutsun ja tietokannan aloituksen. Liitä sisältö uuteen tiedostoon nimeltä array_raw_query.js. Päivitä tietokannan nimeksi sample_student_db:
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);
});Tiedoston loppuun lisää seuraava koodilohko taulukon korvaamista varten, varmistaen, että korvaat REPLACE_STUDENT_ID sillä student_id -arvolla, jonka kopioit edellisessä osassa.
...
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);
});Taulukkovaihtoa varten annetaan query()-metodille SQL-kysely ja konfiguraatio-objekti. Se sisältää replacements-arvon ja tyypin. Vaihtoehtoihin annetaan tiedot taulukkona ja ne otetaan kiinni kysymysmerkkiä (?) käyttämällä.
Seuraavaksi, koska sinun täytyy saada tietoja tietystä opiskelijasta, student_id annetaan toisena parametrina. Tämän jälkeen annat type: sequelize.QueryTypes.SELECT -avain-arvoparin, jota voit käyttää tietojen valitsemiseen tietokannasta.
On myös joitakin muita tyyppejä, kuten QueryTypes.UPDATE ja QueryTypes.DELETE. Vaatimuksista riippuen voit valita tyyppin, joka sopii tarkoitukseesi.
Seuraavassa näytetään koko koodilohko. Tässä muodostat yhteyden tietokantaan ja haet valitun opiskelijan tiedot raakakyselyn avulla.
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);
});Tallenna ja sulje tiedostosi.
Seuraavaksi voit suorittaa tämän skriptin käyttämällä seuraavaa komentoa:
node array_raw_query.jsNäet tulosteen, joka on samanlainen kuin seuraava:
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 } ]Valitun student_id vuoksi tulosarvosi saattavat poiketa.
Objektin korvaaminen
Pintapuolisesti objektin korvaaminen on samanlaista kuin taulukon korvaaminen, mutta tietojen lähettämisen kaava raakakyselyyn on erilainen. Korvausvaihtoehdossa lähetät tiedot objektina, ja kyselyvaihtoehdossa käytät arvoja kuten :key.
Aloittaaksesi luo uusi tiedosto nimeltä object_raw_query.js ja liitä täydelliset koodilohkot server.js-tiedostosta, päivittäen tietokannan sample_student_db-tietokannaksi.
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);
});Lisää sitten seuraava koodilohko uuden object_raw_query.js-tiedoston loppuun:
...
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);
});Tässä saat valittuja opiskelijatietoja käyttämällä objektin korvausmenetelmää. Luo replacement-objekti ja määritä id opiskelijatietona, jonka haluat hakea: { id: '<mark>REPLACE_STUDENT_ID</mark>' }.
Metodissa query() ilmoitat: 'SELECT * FROM students WHERE student_id=:id'. Käyttämällä query()-metodia, toimitat korvaavan arvon objektina, minkä vuoksi tätä menetelmää kutsutaan objektikorvaukseksi.
Tässä on koko koodi:
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);
});Tallenna ja sulje tiedosto.
Seuraavaksi suorita tämä skripti käyttämällä seuraavaa komentoa:
node object_raw_query.jsTuloste näyttää suunnilleen seuraavalta:
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 } ]Valitun student_id vuoksi tulosarvosi saattavat poiketa.
Tässä vaiheessa työskentelit Sequelize:n raakakyselyjen kanssa käyttäen kahta erilaista menetelmää: taulukon korvaamista ja objektin korvaamista.
Ympäristömuuttujien määrittäminen turvallisia tietokantayhteyksiä varten
Tähän asti olet tallentanut tietokantatunnuksia suoraan koodiisi. Vaikka tämä lähestymistapa toimii paikalliseen kokeiluun, se ei ole turvallinen. Tunnusten kovakoodaus paljastaa arkaluonteisia tietoja, kuten tietokannan salasanat ja isäntänimet, ja lisää tietovuotojen riskiä, kun koodi jaetaan tai otetaan käyttöön. Tässä osiossa opit, miten tallentaa nämä tunnukset turvallisesti käyttämällä ympäristömuuttujia.
Miksi käyttää ympäristömuuttujia?
Ympäristömuuttujat toimivat ulkoisina määritysparametreina, joita sovelluksesi voi lukea ajon aikana. Sen sijaan, että liittäisit tunnistetiedot suoraan koodiisi, ne tallennetaan järjestelmääsi tai erilliseen määritystiedostoon, jota ei koskaan tallenneta versionhallintaan. Tämä lähestymistapa tarjoaa useita etuja:
- Turvallisuus: Tunnistetietosi pysyvät piilossa julkisilta arkistoilta ja versionhallintajärjestelmiltä.
- Joustavuus: Jokainen ympäristö (kehitys, testi, tuotanto) voi käyttää eri tietokantakonfiguraatiota muuttamatta lähdekoodia.
- Ylläpidettävyys: Keskitetty konfiguraatio mahdollistaa helpon päivittämisen, jos tietokannan salasana muuttuu, sinun tarvitsee muokata vain yhtä tiedostoa tai muuttujaa.
- Noudattaminen: Tämä käytäntö on linjassa Twelve-Factor App -menetelmän kanssa, joka edistää ympäristökohtaisen konfiguraation hallintaa skaalautuville sovelluksille.
Ympäristömuuttujien määrittäminen
Käytät dotenv-kirjastoa hallitaksesi ympäristömuuttujiasi Node.js:ssä. Tämä kirjasto lukee muuttujat .env-tiedostosta ja lisää ne Node.js:n process.env-objektiin, jolloin ne ovat käytettävissä koko sovelluksessasi.
Asenna dotenv-paketti suorittamalla seuraava komento:
npm install dotenvAsennuksen jälkeen luo uusi tiedosto nimeltä .env projektisi juurikansioon. Tämä tiedosto sisältää kaikki tietokantayhteyteen tarvittavat arkaluonteiset tiedot.
Tässä on esimerkki .env-tiedoston konfiguraatiosta Sequelize-asetuksillesi:
DB_NAME=hello_world_db
DB_USER=your_username
DB_PASSWORD=your_password
DB_HOST=localhost
DB_DIALECT=mysqlJokainen muuttuja vastaa tiettyä parametria, jota Sequelize käyttää yhteyden muodostamiseen.
.env-tiedoston suojaaminen
On erittäin tärkeää, ettei .env-tiedostosi koskaan päädy versionhallintaan. Estääksesi tämän, lisää se .gitignore-tiedostoosi, jotta Git ohittaa sen muutoksia sitouduttaessa:
.envTuotantoympäristöissä ympäristömuuttujat määritellään tyypillisesti suoraan isännöintialustan asetuksissa tai salaisuuksien hallinnassa sen sijaan, että käytettäisiin paikallista .env-tiedostoa.
Sequelizen asetusten päivittäminen
Nyt kun olet määrittänyt ympäristömuuttujat, päivitä Sequelize-alustus käyttämään niitä. Aloita tuomalla ja konfiguroimalla dotenv pääpalvelintiedostosi yläosassa (esim. 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);
});- Rivi
require('dotenv').config()lataa kaikki.env-tiedostossa määritellyt muuttujatprocess.env-ympäristöön. - Sequelize lukee ympäristömuuttujat, kun se alustaa uuden instanssin.
- Tämä varmistaa, ettei esimerkiksi käyttäjätunnuksia tai salasanoja näy koodissasi.
Tämä lähestymistapa parantaa turvallisuutta ja sallii eri ympäristöjen käyttää ainutlaatuisia määrityksiä yksinkertaisesti muuttamalla ympäristömuuttujien arvoja.
Konfiguraation tarkistaminen
Kun olet päivittänyt määrityksesi, voit tarkistaa yhteyden ajamalla Node.js-sovelluksesi:
node server.jsJos .env-tiedostosi on asetettu oikein ja MySQL-palvelin on käynnissä, näet seuraavan tulosteen:
Connection has been established successfully.Jos virhe ilmenee, tarkista, että:
- Tiedostosi
.envtunnistetiedot vastaavat MySQL-instanssisi tunnistetietoja. - MySQL-palvelin on käynnissä ja siihen pääsee käsiksi isäntäjärjestelmästäsi.
.env-tiedosto sijaitsee projektisi juuressa ja on oikein muotoiltu.
Parhaat käytännöt turvalliseen määrittelyyn
Ympäristömuuttujien käyttö on vahva ensimmäinen askel kohti turvallista konfiguraationhallintaa. Jatkuvan turvallisuuden ja luotettavuuden varmistamiseksi kannattaa harkita seuraavia lisäparhaita käytäntöjä:
- Käytä erillisiä asetuksia ympäristöittäin: Säilytä eri
.env-tiedostotdevelopment,stagingjaproduction-ympäristöille. Voit nimetä ne.env.development,.env.stagingja.env.production. - Käytä salaisuuksien hallintatyökaluja: Tuotantoympäristöissä käytä salaisuuksien hallintatyökaluja sen sijaan, että tallennat salaisuuksia tiedostoihin.
- Vahvista ympäristömuuttujat: Käytä konfigurointityökalua tai käynnistysskriptiä, joka tarkistaa, onko tarvittavat muuttujat määritelty ennen sovelluksen suorittamista. Tämä auttaa estämään ajonaikaiset virheet.
- Käännä tunnistetietoja säännöllisesti: Päivitä tietokannan tunnistetiedot säännöllisesti vähentääksesi mahdollisten vuotojen vaikutusta.
- Rajoita tietokannan käyttöoikeuksia: Määritä tietokannan käyttäjäroolit siten, että niillä on sovelluksen tarvitsema vähimmäisoikeustaso.
Ottamalla käyttöön ympäristömuuttujat ja noudattamalla näitä käytäntöjä varmistat, että Sequelize-sovelluksesi säilyttää sekä joustavuuden että turvallisuuden kehitys- ja tuotantoympäristöissä.
Migraatio ja synkronoinnin parhaat käytännöt
Kun kehität tietokantakaaviota, sinulla on Sequelize-sovelluksessa kaksi ensisijaista lähestymistapaa: kirjoittaa ja suorittaa selkeitä migraatioita tai käyttää sequelize.sync()-metodia, jolloin Sequelize luo skeeman muutokset automaattisesti. Molemmat lähestymistavat ovat päteviä, mutta ne palvelevat eri tarkoituksia ja niihin liittyy kompromisseja. Ymmärretään, milloin kutakin kannattaa käyttää, miten kirjoittaa turvallisia migraatioita ja miten suorittaa ne luotettavasti kehityksessä ja tuotannossa.
Migraatiot vs sequelize.sync() — milloin käyttää mitäkin
Migraatiot (suositeltu tuotantoon): Migraatiot ovat eksplisiittisiä, versionhallittuja muutoksia skeemaasi. Ne tallennetaan lähdekoodin hallintaan, koodikatselmoidaan ja suoritetaan osana käyttöönottoprosessia. Käytä migraatioita tuotannossa kaikissa skeemamuutoksissa, jotka vaikuttavat tietojen eheuteen tai saatavuuteen.
sequelize.sync()(käytä vain kehitykseen ja prototyyppeihin):sync()on kätevä paikalliseen kehitykseen, testeihin ja nopeisiin prototyyppeihin, koska se voi luoda tai muokata tauluja automaattisesti. Älä kuitenkaan käytäsync({ force: true })taisync({ alter: true })tuotannossa: nämä valinnat voivat poistaa tietoja tai tehdä turvattomia muutoksia ilman hallittua palautuspolkua.
Työkalut: sequelize-cli ja migraatioiden ajajat
Virallinen komentorivityökalu, sequelize-cli, on yksinkertaisin tapa hallita migrointeja Sequelizen kanssa. Tiimeille, jotka tarvitsevat enemmän hallintaa tai mukautettuja työnkulkuja, umzug on suosittu vaihtoehto.
Asentaaksesi ja alustaksesi CLI:n projektissasi, suorita:
npm install --save-dev sequelize-cli
npx sequelize-cli initTämä luo seuraavat kansiot:
config/ # Stores database configuration files
models/ # Stores your Sequelize model definitions
migrations/ # Stores migration files
seeders/ # Stores seeder files for inserting initial dataSinun tulisi lisätä nämä kansiot versionhallintaan (pois lukien kaikki tiedostot, jotka sisältävät tunnistetietoja). Tämä varmistaa, että jokainen ympäristö käyttää samoja tietokantamuutoksia johdonmukaisesti.
Migraatioiden luominen ja suorittaminen
Luodaksesi uuden migraatiotiedoston, käytä seuraavaa komentoa:
npx sequelize-cli migration:generate --name add-isbn-to-booksTämä luo aikaleimatun tiedoston migrations/-kansioon. Avaa tiedosto ja määrittele, mitä tapahtuu, kun sovellat migraation (up) ja miten se peruutetaan (down):
module.exports = {
async up(queryInterface, Sequelize) {
await queryInterface.addColumn('books', 'isbn', {
type: Sequelize.STRING
});
},
async down(queryInterface) {
await queryInterface.removeColumn('books', 'isbn');
}
};up-funktio suorittaa migraation (lisää sarakkeen).down-funktio kumoaa muutoksen (poistaa sarakkeen).
Suorita migraatio käyttämällä:
npx sequelize-cli db:migrateViimeisen migraation peruuttamiseksi käytä:
npx sequelize-cli db:migrate:undoVoit myös peruuttaa kaikki migraatiot kehityksessä suorittamalla:
npx sequelize-cli db:migrate:undo:allTurvallisten, idempotenttien migraatioiden kirjoittaminen
Noudata näitä sääntöjä laatiessasi migraatioita:
Pakkaa toiminnot transaktioihin, kun tietokanta sitä tukee. Tämä varmistaa, että migraatio onnistuu kokonaan tai peruutetaan kokonaan virheen sattuessa.
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 }); }); } };Pidä migraatiot pieniä ja keskittyneitä. Jokaisen migraation tulisi tehdä yksi looginen muutos (lisätä sarake, luoda indeksi, nimetä sarake uudelleen). Pienemmät migraatiot on helpompi tarkistaa, testata ja peruuttaa.
Ole varautunut ja idempotentti. Tarkista tarvittaessa olemassaolo välttääksesi virheet ympäristöissä, joissa on poikkeamia. Käytä
queryInterface.describeTable()-metodia tai raakakyselyjä turvataksesi toiminnot.Vältä tuhoavia toimenpiteitä yhdellä kertaa. Esimerkiksi poistettaessa saraketta turvallisesti, lisää uusi sarake, täytä se tiedoilla, vaihda sovelluskoodissa lukemaan uusi sarake, ja vasta sen jälkeen poista vanha sarake myöhemmässä migraatiossa.
Pitkäkestoiset ja katkeamattomat siirrot
Suuret taulukot ja indeksioperaatiot voivat aiheuttaa lukkoja. Käytä näitä strategioita vaikutusten minimoimiseksi:
- Lisää ensin sallitut null-arvot sisältävät sarakkeet. Sallittujen null-arvojen sisältävän sarakkeen lisääminen on yleensä nopeaa. Vältä sarakkeiden lisäämistä, joilla on ei-triviaaleja oletusarvoja, jotka aiheuttavat koko taulun uudelleenkirjoituksen.
- Täytä taustatiedot pienissä erissä. Toteuta taustaprosessi uusien sarakkeiden täyttämiseksi paloissa sen sijaan, että suorittaisit yhden suuren
UPDATE-komennon. - Luo indeksejä ilman yksinoikeuslukkoja, missä mahdollista. Käytä tietokantakohtaisia ominaisuuksia (esimerkiksi Postgres
CONCURRENTLYja uudemmat MySQL online DDL -toiminnot) raaka-SQL:n avulla migraatioissa. - Ominaisuuspohjaisten lippujen käyttöönotot. Ota käyttöön sovelluskoodi, joka lukee uuden sarakkeen ominaisuuspohjaisen lipun takaa. Kun tiedon täydennys on valmis ja testit onnistuvat, käännä lippu ja poista myöhemmin vanha kenttä.
Peruutukset ja hätäkorjaukset
- Tarjoa
down-migraatio. Jokaisellaup-migraatiolla tulisi olla käänteinendown, joka dokumentoi, miten muutos voidaan kumota. Vaikka käyttäisitdown-komentoa harvoin tuotannossa, se toimii selkeänä peruutussuunnitelmana. - Suunnittele hätäpaluut etukäteen. Jos migraatio aiheuttaa ongelmia, varaudu palauttamaan sovelluskoodi ensin ja palauttamaan tietokanta varmuuskopioista tarvittaessa. Testaa palautusproseduurit säännöllisesti.
Tietojen ja skeeman muutosten alustaminen
- Pidä seed-tiedot minimissä ja vakaana. Käytä seedereitä vain olennaisiin hakuihin tai konfiguraatioriveihin. Vältä suurten liiketoimintadatan määrien syöttämistä migraatioiden kautta.
- Erota siemenet rakenneuudistuksista. Jos sinun täytyy täyttää tietoja, jotka riippuvat skeeman muutoksesta, suosittelemme käyttämään erillistä siemenlataajaa, jotta vastuut pysyvät selvillä.
CI, koodikatselmointi ja käyttöönoton automaatio
Suorita migraatiot ensin CI:ssä ja staging-ympäristössä. Lisää CI-vaihe, joka suorittaa migraatiot hetkellisessä tietokannassa virheiden havaitsemiseksi varhain.
Käsittele migraatioita kuin koodia. Tarkista ja käy läpi migraatiotiedostot pull requesteissa. Sisällytä automaattisia tarkistuksia mahdollisuuksien mukaan.
Automatisoi migraatioiden suoritus käyttöönoton aikana. Varmista, että migraatiot ajetaan ennen kuin sovellusprosessit alkavat käsitellä liikennettä. Esimerkki
package.json-skripteistä:"scripts": { "migrate": "npx sequelize-cli db:migrate", "start": "node server.js", "deploy": "npm run migrate && npm run start" }
Konttien avulla toteutetuissa käyttöönotoissa suorita migraatiot init-konttina tai käyttöönotto-koukussa, jotta verkkoprosessit käynnistyvät vasta migraatioiden valmistuttua.
Migraatioiden testaaminen
- Testaa molempiin suuntiin. Suorita
db:migrateja sittendb:migrate:undo:allpaikallisesti ja CI:ssä varmistaaksesi, ettäupjadowntoimivat molemmat. - Käytä kertakäyttöisiä tietokantoja testeissä. Suosi lyhytikäisiä tietokantoja tai kontteja deterministisiin testiajohin.
Näiden parhaiden käytäntöjen noudattaminen varmistaa, että Sequelize-migraatiot pysyvät luotettavina, jäljitettävinä ja turvallisina pitkäaikaisissa projekteissa.
Vianmääritys ja suorituskykyvinkit
Even with a solid setup, Sequelize -sovellukset voivat joskus kohdata odottamattomia ongelmia, kuten tietokantayhteysvirheitä, migraatiovirheitä, hitaasti toimivia kyselyjä, lukkiutumia tai samanaikaisuuskonflikteja. Tässä osiossa annetaan vaiheittaiset ohjeet näiden ongelmien tunnistamiseen ja korjaamiseen sekä suorituskyvyn parhaita käytäntöjä, jotka auttavat pitämään sovelluksesi vakaana ja tehokkaana.
Yleisimpien ongelmien vianmääritys
1. Yhteysvirheet
Ongelma: Sequelize ei voi muodostaa yhteyttä MySQL-tietokantaan ja antaa virheilmoituksia, kuten SequelizeConnectionError: connect ECONNREFUSED, Access denied for user tai SequelizeHostNotFoundError.
Kuinka korjata:
Aloita varmistamalla, että yhteystietosi ovat oikein. Tarkista arvot .env-tiedostossasi, mukaan lukien tietokannan nimi, käyttäjänimi, salasana, palvelin ja portti. Jo pienikin kirjoitusvirhe tai ylimääräinen välilyönti voi estää Sequelizea muodostamasta yhteyttä.
Seuraavaksi varmista, että MySQL-palvelimesi on käynnissä ja kuuntelee oletusporttia (3306). Voit testata yhteyden muodostamista kirjautumalla sisään manuaalisesti:
mysql -u your_username -p -h your_host -P 3306Jos tämä komento epäonnistuu, ongelma johtuu todennäköisesti MySQL-palvelustasi tai tunnistetiedoistasi.
Jos käytät dotenv-pakettia, varmista, että require('dotenv').config() tulee ennen kuin Sequelize alustetaan. Tämä vaihe varmistaa, että kaikki ympäristömuuttujat ovat käytettävissä ajon aikana.
Lopuksi etäyhteyksien osalta tarkista palomuuriasetuksesi tai suojausryhmäsäännöt. MySQL-palvelimen on hyväksyttävä sisääntulevat yhteydet sovelluksesi isäntäkoneesta.
2. Siirtymävirheet
Ongelma: Kun suoritat npx sequelize-cli db:migrate tai sequelize.sync(), kohtaat virheitä, kuten puuttuvat taulut, kaksoiskappaleet sarakkeissa tai skeeman epäsuhta.
Kuinka korjata:
Migraatio-ongelmia esiintyy yleensä, kun tiedostoja suoritetaan väärässä järjestyksessä tai niissä on virheitä SQL-toiminnoissa. Sequelize käsittelee migraatioita tiedostonimien aikaleimojen perusteella, joten varmista, että tiedostot on nimetty oikein.
Jos siirto epäonnistuu, tarkista virheilmoitus huolellisesti. Palauta sitten viimeinen siirto turvallisesti käyttämällä:
npx sequelize-cli db:migrate:undoKorjattuasi siirtotiedoston, suorita se uudelleen.
Kääri aina migraatiologiikkasi transaktioon varmistaaksesi atomisuuden: joko kaikki muutokset onnistuvat tai mikään ei onnistu. Ennen migraatioiden suorittamista tuotannossa, testaa ne huolellisesti esikatselu- tai paikallisdatabaseissa varmistaaksesi niiden oikeellisuuden.
3. Mallin synkronointiongelmat
Ongelma: Sequelize-mallisi ja tietokantakaaviosi eivät vastaa toisiaan, mikä johtaa puuttuviin sarakkeisiin, virheellisiin tietotyyppeihin tai vanhentuneisiin tauluihin.
Kuinka korjata:
Vältä sequelize.sync({ force: true }) -kutsun käyttöä tuotannossa, sillä se poistaa ja luo taulut uudelleen, aiheuttaen pysyvän tietojen menetyksen. Vastaavasti käytä sequelize.sync({ alter: true }) -kokoonpanoa varoen; se voi muuttaa skeemoja ennakoimattomasti.
Sen sijaan käytä mieluummin selkeitä migraatioita, jotka määrittelevät jokaisen skeeman muutoksen tarkasti. Vertataksesi mallejasi varsinaiseen tietokantarakenteeseen, käytä:
await queryInterface.describeTable('tableName');Tämä auttaa havaitsemaan epäsuhtaisuuksia ennen kuin ne vaikuttavat tuotantoon.
4. Kysely- ja aikakatkaisun virheet
Ongelma: Näet aikakatkaisuun liittyviä virheitä, kuten Yhteyden aikakatkaisu tai Liian monta yhteyttä.
Kuinka korjata:
Aikakatkaisuongelmat johtuvat usein tyhjentyneistä yhteyspoolista tai sulkemattomista yhteyksistä. Varmista, että kaikki Sequelize-kyselyt odotetaan oikein, jotta yhteydet palautuvat pooliin käytön jälkeen.
Voit myös hienosäätää Sequelize:n poolin asetuksia paremmin sovelluksesi kuormitusta varten:
const sequelize = new Sequelize(DB_NAME, DB_USER, DB_PASSWORD, {
host: DB_HOST,
dialect: 'mysql',
pool: {
max: 10,
min: 0,
acquire: 30000,
idle: 10000
}
});Jos sovelluksesi käsittelee monia samanaikaisia käyttäjiä, harkitse MySQL-tietokannan max_connections-parametrin kasvattamista tietokantakonfiguraatiossasi. Seuraa aktiivisia yhteyksiä käyttämällä MySQLissä SHOW PROCESSLIST; liikavuuksien tai käyttämättömien istuntojen havaitsemiseksi.
5. Hitaat kyselysuoritukset
Ongelma: Tietyt kyselyt kestävät odotettua pidempään, mikä aiheuttaa hitaita API-vastauksia tai suurta viivettä.
Kuinka diagnosoida:
Aloita tunnistamalla, mitkä kyselyt ovat hitaita. Voit kirjata kaikki Sequelize:n suorittamat kyselyt ottamalla lokituksen tilapäisesti käyttöön:
const sequelize = new Sequelize(..., { logging: console.log });Käytä sitten MySQL:n EXPLAIN-lausetta ymmärtääksesi, miten tietokanta suorittaa kyselyn:
EXPLAIN SELECT * FROM users WHERE email = 'user@example.com';Jos tuloste näyttää 'täyden taulun haun', kyselyltä puuttuu indeksi.
Voit myös ottaa MySQLin hitaan kyselyn lokin käyttöön kaapataksesi hitaat toiminnot automaattisesti:
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1;Kuinka korjata:
Lisää indeksejä usein kyselyissä käytettäville sarakkeille (erityisesti niille, joita käytetään WHERE, JOIN ja ORDER BY -lauseissa). Vältä SELECT *-käskyä; hae sen sijaan vain tarvitsemasi kentät käyttämällä attributes-asetusta.
Jos Sequelize luo tehottomia kyselyjä, joissa on tarpeettomia yhdistämisiä, kirjoita kysely uudelleen käyttämällä raakaa SQL:ää. Suuria raportteja tai analytiikkakyselyjä varten jaa ne pienempiin osiin tai käytä välimuistityökaluja, kuten Redis, tallentaaksesi toistuvat tulokset.
6. Lukkiutumat ja samanaikaisuuden virheet
Ongelma: Saat virheilmoituksia kuten Deadlock found when trying to get lock; try restarting transaction, erityisesti suuren kuormituksen aikana.
Kuinka diagnosoida:
Tarkista InnoDB:n tila MySQL:ssä selvittääksesi, mitkä kyselyt tai taulut olivat mukana:
SHOW ENGINE INNODB STATUS\GTämä tuloste sisältää yksityiskohtaista tietoa viimeaikaisista lukitustilanteista ja odottavista lukituksista. Voit myös ottaa käyttöön yleiset tai transaktiolokit tarkastellaksesi kyselyjen järjestystä, joka johti ongelmaan.
Kuinka korjata:
Verkkolukitukset tapahtuvat, kun kaksi tai useampi transaktio odottaa toistensa lukkoja. Niiden minimoimiseksi:
Pidä tapahtumat mahdollisimman lyhyinä. Älä kutsu ulkoisia palveluita tai tee raskasta laskentaa lukkotilassa.
Käytä tauluja ja rivejä aina samassa järjestyksessä eri tapahtumissa välttääksesi ympyräiset odotukset.
Toistuvien jumiutumisten vuoksi toteuta yksinkertainen uudelleenyritysmekanismi eksponentiaalisella viiveellä:
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; } } }Käytä rivitason lukkoja (
SELECT ... FOR UPDATE) vain tarvittaessa ja vapauta ne viipymättä.Jaa suuret tapahtumat pienempiin eriin vähentääksesi ristiriitoja.
Säädä transaktioiden eristystasoja tarvittaessa, mutta vain sen jälkeen kun olet varmistanut, ettei se vaikuta tietojen johdonmukaisuuteen.
Suorituskyvyn optimointivinkkejä
Suorituskykyongelmat johtuvat usein tehottomista kyselyistä, puuttuvista indekseistä tai huonosta yhteydenhallinnasta. Tässä muutamia käytännön vinkkejä Sequelize-suorituskyvyn parantamiseen tinkimättä selkeydestä tai ylläpidettävyydestä.
1. Optimoi kyselyt
Kirjoita kyselyitä, jotka pyytävät vain tarvittavat tiedot. Tarpeettomien tietojen hakeminen lisää muistinkulutusta ja hidastaa vasteita. Käytä attributes rajoittaaksesi kenttiä:
const users = await User.findAll({ attributes: ['id', 'name'] });Suodata tulokset aina indeksoituja sarakkeita käyttäen ja vältä tarvittaessa laajoja hakuja, kuten LIKE '%term%'.
2. Käytä indeksejä tehokkaasti
Indeksit nopeuttavat hakuja, mutta voivat hidastaa kirjoituksia. Lisää indeksejä vain sinne, missä ne tuottavat mitattavissa olevaa hyötyä. Analysoi kyselyjen suorituskykyä MySQL:n EXPLAIN-komennolla varmistaaksesi parannukset ennen indeksin lisäämistä ja sen jälkeen:
await queryInterface.addIndex('users', ['email']);3. Viritä yhteyspooli
Yhteyspooli määrittää, kuinka monta tietokantayhteyttä Sequelize ylläpitää.
- Pienille sovelluksille 5–10 yhteyttä riittää yleensä.
- Suuren kuormituksen järjestelmissä kasvata poolin kokoa ja säädä aikakatkaisuja estääksesi yhteyshäiriöitä. Seuraa käyttöä säännöllisesti MySQL:n komennolla
SHOW PROCESSLIST;.
4. Ota lokitus ja seuranta käyttöön
Ota Sequelize-lokin hallinta väliaikaisesti käyttöön SQL-kyselyjen tarkastelua varten. Käytä MySQL:n hitaiden kyselyjen lokia tunnistaaksesi kyselyt, jotka ylittävät suorituskykyrajan. Reaaliaikaista seurantaa varten integroi valvontatyökaluja, kuten PM2, New Relic tai Datadog, mitataksesi viivettä ja resurssien käyttöä.
5. Välimuisti usein kysytyille kyselyille
Välimuistita tulokset tiedoille, jotka eivät muutu usein. Työkalut kuten Redis tai Memcached vähentävät tietokantakyselyjä ja parantavat vasteaikoja, erityisesti lukuintensiivisissä kuormissa.
6. Sivuuta tulokset
Suuret tulossarjat kuluttavat huomattavasti muistia. Pilko kyselyt aina sivutuksella API:issa:
const users = await User.findAll({ limit: 50, offset: 100 });Sivutus pitää vastaukset kevyinä ja tasaisina kuormituksen aikana.
7. Käytä raakakyselyjä monimutkaisiin operaatioihin
Jos Sequelizen abstraktio johtaa tehottomaan SQL-kyselyyn tietyssä käyttötapauksessa, suorita raakaa SQL-kyselyä suoraan:
const [results] = await sequelize.query('SELECT name FROM users WHERE active = 1');Käytä raakakyselyjä säästeliäästi ja dokumentoi ne selkeästi tulevaa ylläpitoa varten.
UKK
1. Mikä on Sequelize Node.js:ssä?
Sequelize on Node.js:lle tarkoitettu objekti-relationaalinen mallintaja (ORM), joka tarjoaa korkean tason, JavaScript-pohjaisen API:n työskennellä SQL-tietokantojen, kuten MySQL:n, PostgreSQL:n, SQLite:n ja MariaDB:n kanssa. Sen sijaan, että kirjoittaisit raakaa SQL:ää jokaisessa operaatiossa, määrittelet malleja, jotka vastaavat tietokantatauluja, ja käytät mallien metodeja tietueiden lisäämiseen, kyselyihin, päivittämiseen ja poistamiseen. Sequelize tukee myös assosiaatioita (mallien välisiä suhteita), transaktioita, migraatioita ja raakakyselyjä silloin, kun tarvitset suoraa SQL:ää.
2. Kuinka yhdistän Sequelizen MySQL:ään?
Yhdistääksesi Sequelizeen MySQL:iin, sinun tulee luoda Sequelize-instanssi käyttämällä tietokantatunnuksiasi ja asetuksiasi. Node.js-tiedostossa, vaadi Sequelize, lataa tarvittaessa ympäristömuuttujat, ja luo sen jälkeen instanssi käyttämällä tietokannan nimeä, käyttäjänimeä, salasanaa sekä host/dialect-asetuksia. Esimerkiksi:
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!');Pidä tunnistetiedot aina versionhallinnan ulkopuolella (esimerkiksi .env-tiedostossa tai salaisuuksien hallintatyökalussa).
3. Kuinka luon ja synkronoin malleja Sequelizessä?
Sequelizessa mallit edustavat tauluja. Voit määritellä ne käyttämällä sequelize.define()-metodia tai laajentamalla Model-luokkaa. Tämän jälkeen voit synkronoida ne tietokantasi kanssa, jolloin Sequelize luo taulut automaattisesti (erinomaista kehitykseen). Tässä on pieni esimerkki:
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();Tuotantoympäristöissä on parempi käyttää migraatioita, jotta sinulla on versiohallinta skeeman muutoksille.
4. Kuinka käytän Sequelizetä Expressin kanssa?
Express-sovelluksessa alustetaan Sequelize erillisessä tiedostossa (kuten db.js), viedään yhdistetty instanssi ja mallit, ja tuodaan ne siihen kohtaan, missä niitä tarvitaan reittien käsittelijöissä tai ohjaimissa. Käytä async/awaitia reittien käsittelijöissä kutsuaksesi Sequelize-mallien metodeja, ja käsittele virheitä try/catchilla tai virheiden middlewarellä. Näin se käytännössä näyttää:
// 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);
});Varmista, että suoritat migraatiot tai kutsut sequelize.sync() ennen Express-palvelimen käynnistämistä, jotta tietokantataulusi ovat olemassa, kun pyynnöt saapuvat.
5. Mikä on ero Sequelize:n ja raakaa SQL:ää käyttävien kyselyiden välillä?
Sequelize antaa sinun kirjoittaa tietokantalogiiikkaa JavaScriptillä, kun taas raakaa SQL:ää käyttäessä kirjoitat SQL-lauseet suoraan. Sequelize tekee koodistasi siistimpää ja helpommin ylläpidettävää, koska voit määritellä mallit ja suhteet kerran ja käyttää niitä sovelluksessasi. Raaka SQL antaa enemmän hallintaa ja voi joskus olla nopeampi hyvin monimutkaisissa kyselyissä.
Lyhyesti sanottuna, käytä Sequelizeä useimpiin päivittäisiin tehtäviin ja käytä raakaa SQL:ää, kun sinun tarvitsee hienosäätää suorituskykyä tai suorittaa jotain, mitä Sequelize ei helposti ilmaise.
6. Kuinka voin määritellä yhteyksiä Sequelizessa?
Sequelize tekee taulujen välisistä suhteista kuvaamisen helpoksi. Voit määrittää yksi-yhteen, yksi-moniin tai moni-moniin -suhteita käyttämällä yksinkertaisia menetelmiä, kuten hasOne, hasMany ja belongsToMany. Esimerkiksi:
// 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' });Kun se on määritelty, voit käyttää include-komentoa kyselyissäsi hakeaksesi automaattisesti liittyviä tietoja.
7. Miten käsittelen migraatioita ja skeeman muutoksia?
Kehityksessä voit käyttää sequelize.sync()-komentoa taulujen luomiseen nopeasti. Tuotannossa sinun tulisi kuitenkin aina käyttää migraatioita. Migraatiot ovat versioituja tiedostoja, jotka kuvaavat, miten tietokantasi rakenne muuttuu ajan myötä, samalla tavalla kuin Git-commitit seuraavat koodin muutoksia.
Voit luoda migraation Sequelize CLI:llä:
npx sequelize-cli migration:generate --name add-users-tableJokaisella migraatiolla on up- ja down-metodit, yksi muutoksen tekemiseen ja yksi sen kumoamiseen. Suorita migraatiot komennolla:
npx sequelize-cli db:migrateNäin kaikki tiimissäsi (ja jokainen käyttöönotto) säilyttävät saman tietokantarakenteen.
Käytä sequelize.sync() nopeisiin kokeiluihin, mutta pysy siirroissa kun sovelluksesi on käyttövalmis, koska ne ovat turvallisempia, palautettavissa ja helpommin seurattavia.
Johtopäätös
Tässä opetusohjelmassa asensit Sequelize:n Node.js:n ja MySQL:n kanssa hallitsemaan tietoja mallien, assosiaatioiden ja migraatioiden kautta. Lisäksi suojasit tietokantatunnuksesi ympäristömuuttujilla ja tutustuit parhaisiin käytäntöihin vianmäärityksessä ja suorituskyvyn optimoinnissa.
Näiden vaiheiden avulla sinulla on nyt vankka perusta turvallisten ja tehokkaiden Node.js-sovellusten rakentamiseen ja ylläpitämiseen, jotka käyttävät Sequelizeit ja MySQL:ää tietojen hallintaan.
Jos haluat oppia lisää Sequelizesta, tutustu tuotteen dokumentaatioon. Lisätäkseksi muita Node.js-ohjeita, katso seuraavat artikkelit:
- Kuinka perustaa GraphQL-palvelin Node.js:ssä käyttäen Apollo Serveriä ja Sequelizea
- Kuinka toteuttaa välimuisti Node.js:ssä käyttäen Redis
- Kuinka luoda verkkopalvelin Node.js:ssä HTTP-moduulin avulla
Kiitos, että opiskelet Linux-Console.net -yhteisön kanssa.