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).
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!