Come utilizzare un orm in node.js

logo node.js

In questo blog Parlerò di un po ‘delle orme, i loro benefici (professionisti) e limitazioni (contro), che è sequelize e come usarlo.

Oggetto-mappatura relazionale

è a Tecnica per convertire i dati tra il sistema di programmazione dei tipi di linguaggio e del database. Come indica il nome, questo è indirizzato solo al database relazionale (SQL). Questo crea un effetto “Virtual Database Object” sul database relazionale, questo effetto è ciò che ci consente di manipolare il database attraverso il codice.

Oggetto – Riferimento all’oggetto / S) che possiamo usare in la nostra lingua.

relazionale – si riferisce al nostro sistema di gestore database (MySQL, MSSQL, PostgreSQL).

Mapping – Riferimento è fatto riferimento alla connessione tra gli oggetti e le tabelle.

TL; DR ORM è una tecnica che ci consente di creare domande e manipolare i dati dal database da un linguaggio di programmazione.

Pro

  • astratto: design di una struttura o modello isolato dal database.
  • portatile: consente di trasportare la struttura del tuo orm qualsiasi dbms.
  • nidificazione dei dati: Nel caso in cui una tabella ha una o più relazioni con gli altri.

contro

  • lento: se si confronta il tempo di risposta tra una query raw e una query fatta di Oggetti, la query grea è molto più veloce perché non c’è strato (mappatura).
  • complessità: a volte avremo bisogno di creare query complesse, fortunatamente sequelize consente di eseguire query raw.

>

che è sequelize?

sequelize è un orm basato su promesse per node.js. Supporta PostgreSQL, MySQL, SQLite e MSSQL e offrono caratteristiche solide di transazioni, relazioni tra tabelle, meccanismi di migrazione e caricamento dei dati e altro ancora.

perché ho deciso di usare sequelize?

sequelize gestisce i tuoi oggetti come promesse, qualcosa che va di pari passo con il ciclo dell’evento del nodo.js.

Ora ti mostrerò come creare e migrare tabelle, caricare dati e come consultare questi dati. Se si desidera controllare il codice, puoi clonarlo da qui.

Requisiti

  • node.js 8.0 +
  • mysql 5.7 +

Installare prima il modulo sequelize-cli:

 NPM I -G sequelize-cli 

Creeremo una cartella in cui contiene la nostra applicazione, creeremo un file JS e installeremo sequelize e il suo dialetto (in questo caso mysql):

 mkdir howto -seselize & & cd howto-sequelizetouch index.jsnpm init -ynpm i -s sequelize mysql2 

Ora noi Per avviare il progetto con Sequelize-CLI:

 sequelize init 

sequelize-cli ha creato una struttura di base alla radice del nostro progetto:

Se recendiamo il file ./config/config.json, vediamo che abbiamo 3 opzioni di connessione a un database, Modifica l’opzione “Sviluppo”:

 "sviluppo": {"username": "root", "password": "tucontraseña", "database": "Howto-sequerize", "host": "127.0.0.1", "dialetto": "mysql" "Operatorsaliase": false, "Dialectoptions": {"charset": "utf8mb4"}, "logging": true, "benchmark": true} 

ora rivedere il file ./models/index. Js. Questo file ha una funzione per creare una nuova istanza di sequelize ogni volta che viene chiamato, e ha una variabile di ambiente predefinita su “sviluppo”, che utilizzerà il database, l’host, l’utente, la password e le opzioni che abbiamo appena aggiunto.

Riteniamo il nostro database con il seguente comando:

 sequelize db: Crea 

Molto bene! Ora iniziamo a creare il nostro Modelli:

 Sequelize Modello: Genera --Name User - Tributate Nome: stringa, cognome: stringa, alaverdom: stringa, e-mail: String Sequelize Model: Genera - - - Nome LanguageP - Nome di Language: String SequIize Modello: Genera --Name User_Lenguajep --TributesUsUnoid: Integer, Lingua: intero 

Dopo aver creato i nostri modelli è necessario fare la relazione tra utenti e lingue.

./ modelli / user.js

 'Usa rigoroso'; modulo.exports = (sequelize, datatipi) =  {var utente = asciutto lize.define ('User', {Nome: DataTypes.String, cognome: DataTypes.String, Alaverdom: dataTypes.String, Email: dataTypes.String}, {}); Utente.associate = funzione (modelli) {// associazioni può essere definita qui utente.Belongstoman (modelli.Lingua, {through: 'user_lenguajep', come: 'linguePrograming', ForeignKey: 'ID utente',}); Ritorna l'utente;}; 

Analizziamo questo, vediamo che il nostro modello utente esegue una funzione di apparizione che punta al modello di lingua, in poche parole che indicano che un utente può appartenere a diverse lingue. Nelle opzioni, attraverso la tabella per il quale devi attraversare queste relazioni, poiché è facoltativo, è il nome della proprietà o della chiave che ci darà queste relazioni, il marchio ForeignKey perché la colonna vogliamo cercarli Relazioni.

./ Modelli / LanguageP.js

 'Utilizzare rigoroso'; modulo.exports = (sequelize, DataTypes) =  {VAR LanguageP = sequelize.Define ('LanguageP', {Nome: DataTypes.String}, {}); LanguageP.Associate = Funzione (Modelli) {// Le associazioni possono essere definite qui LanguageP.Belongstomany (models.suario, {throunds.suario, {through: 'user_lenguajep', come: 'Utenti', ForeignKeyKey: 'LanguagePID',}); Return Languagep;}; 

Facciamo lo stesso con le lingue (LanguageP), ma ora indicando il modello utente.

Ricordiamo un po ‘di cui parliamo, orm Funziona su uno strato che è la mappatura (mappatura), queste relazioni saranno eseguite solo nel progetto, dobbiamo creare una migrazione che influisce sul database. Ci sono orm che riescono a revisione se hai apportato modifiche ai tuoi modelli e crea nuove migrazioni basate su tali modifiche (Django Orm, Peewee), nel nostro caso sequelize non ce l’ha, quindi creeremo le nostre migrazioni:

 Sequelisize Migration: Generare - Nome Relazione-Molti-to-molti 

Generato un nuovo file con uno scheletro nelle nostre migrazioni, ora dobbiamo modificarlo :

 'Usa rigoroso'; modulo.exports = {up: (queryinterface, sequelize) =  {return, {Tipo: 'tasto straniero', nome: 'fk_usuariolegajep_usuaro_1', riferimento: {Tabella: 'utente' , Campo: 'ID',}, OnDelete: 'NESSUNA AZIONE', ONUPDATE: 'NESSUNA AZIONE',}), QUERYINTERFACEFACE.ADDCONSTRAINT ('USER_LENGUAJEP' ,, {TIPO: 'CHIAVE ESTERA', NOME: 'fk_usuarolegegajap_Lenguep_1', riferimenti_lenguep_1 ', riferimenti : {Tabella: 'LanguageP', campo: 'ID',}, OnDelete: 'Nessuna azione', OnUpdate: 'Nessuna azione',}),]}, Giù: (Queryinterface, sequelize) =  {return}}; 

Questo file esporta un oggetto con 2 proprietà, su e giù. La proprietà up è incaricata di fornire una promessa che altera i dati (creare tabelle, relazioni, campi, tipi di modifica, ecc.), E la proprietà down diversamente, ripristina le modifiche apportate in su.

Molto bene, ora tocca la mia parte preferita, devi eseguire gli script di migrazione con il seguente comando:

 sequelize db: migrate 

BOOM! Ma cosa è successo?!?! Se leggiamo attentamente l’errore nella console, afferma che non trova la tabella utente_Lenguajet nel database, rivedere le tabelle. C’è qualcosa di curioso, tutto finisce con una “s”, questo perché Sequelisize-cli gestisce le schede in plurale per impostazione predefinita, anche quando nelle nostre opzioni abbiamo freezetableName: True, questo caso può essere visto qui.

Allora dobbiamo solo cambiare il nome delle tabelle un plurale in relazione-molti-a-molti (user_lenguajeps, utenti, languageps).

Annulla le migrazioni, spostare indietro e voilà :
 Sequelisize DB: Migrazione: Annulla: AlluesElize DB: Migrazione 

Le migrazioni hanno avuto successo! Ora dobbiamo popolare queste tabelle, Sequelisize-CLI utilizza i semi (semi). Creeremo 3 file di semi:

 Seed Seed: Genera --Name Userselize Seed: Genera --Name LanguageSelezeze Seeds: Generate --Name User_Lenguajap 

Questi semi si trovano nella cartella. /seeders, devi mettere i dati che Vogliamo caricare nel database.

semi Tutto Utente:

 'Usa rigoroso'; modulo.exports = {up: (queryinterface, sequelize) =  {return queryinterface.bulkinsert ('utenti', {}); }, Giù: (queryinterface, sequelize) =  {return queryinterface.bulkdelete ('utenti', null, {}); }}; 

Seed LanguageP:

 'Usa rigoroso'; modulo.exports = {up: (queryinterface, sequelize) =  {return queryinterface.bulkinsert ('Languageps', {}); }, Giù: (Queryinterface, sequelize) =  {return queryinterface.bulkdelete ('LanguagePS', NULL, {}); }}; 

seed user_lenguajep:

 'usare rigoroso'; modulo.exports = {up: (queryinterface, sequelize) =  {return queryinterface.bulkinsert ('user_lenguajeps' ,, {}); }, Giù: (Queryinterface, sequelize) =  {return queryinterface.BulkDelete ('user_lenguajeps, null, {}); }}; 

Ora è necessario caricare questi dati nel database con il seguente comando:

 sequelize db: seme: tutto 

Molto bene! Abbiamo già visto come inizializzare un progetto con sequelize, creare modelli, assegnare relazioni, creare migrazioni, eseguire e annullare le migrazioni, creare semi e caricarli nel database, abbiamo solo bisogno di fare query. Andiamo al nostro indice.js nella radice e scriviamo la seguente funzione:

 CONST DB = Richiedere ('./ Models'); CONST MAIN = ASYNC () =  {TRY {CONST UTENTI = AWAITA DB.SUARIO.FINDALL ({include:}, tramite: {Attributi:},}],}); Console.log (json.Stringify (utenti)); Processo.exit (); } catch (errore) {console.log (errore); }};;; Main (); 

lo salviamo ed esegue il programma (per console o con lo strumento di debug del codice di Visual Studio e dovremmo ricevere un JSON con un elenco di utenti (in questo esempio c’è solo uno) con i tuoi dati e lingue:

}] 

Abbiamo imparato sequelize-cli e le basi di sequelize, ora possiamo creare un’API che esegue Azioni crudo in modo che i nostri clienti si consumino!

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *