Como usar un ORM en node.js

Logotipo node.js

Neste blog Vou falar dun pouco sobre o ORMS, os seus beneficios (pros) e limitacións (CONS), que é secuela e como usalo.

MAPATING TRABALLO-Relacional

é a Técnica para converter datos entre o sistema de programación de tipos de linguaxe e base de datos. Como o seu nome indica, só se dirixe á base de datos relacional (SQL). Isto crea un efecto “obxecto de base de datos virtual” na base de datos relacional, este efecto é o que nos permite manipular a base de datos a través do código.

Obxecto – referencia a / o obxecto (s) que podemos usar en a nosa lingua.

Relacional – refírese ao noso sistema de xestión de bases de datos (MySQL, MSSQL, PostgreSQL).

Mapping – Referencia é referida á conexión entre os obxectos e as táboas.

tl; Dr orm é unha técnica que nos permite facer preguntas e manipular datos da base de datos a partir dunha linguaxe de programación.

pros

  • Resumo: deseño dunha estrutura ou modelo illado da base de datos.
  • portátil: permítelle transportar a estrutura do seu orema calquera DBMS.
  • Nesting de datos: No caso de que unha mesa teña unha ou máis relacións cos demais.

con

  • lento: se compara o tempo de resposta entre unha consulta crúa e unha consulta feita by. Obxectos, a consulta bruta é moito máis rápida porque non hai capa (mapeamento).
  • complexidade: Ás veces teremos que facer consultas complexas, por sorte que a secuela permítelle executar consultas en bruto.

que é secuela de secuela?

Sequelize é un ORM baseado en promesas de node.js. Soporta PostgreSQL, MySQL, SQLITE e MSSQL, e ofrece características sólidas de transaccións, relacións entre táboas, mecanismos de migración e carga de datos e moito máis.

porque decidín usar secuela?

Sequelize manexa os seus obxectos como promesas, algo que vai da man co bucle do evento de node.js.

Agora vou amosar como crear e migrar táboas, subir datos e como consulta estes datos. Se desexa comprobar o código, pode clonalo desde aquí.

requisitos

  • node.js 8.0 +
  • MySQL 5.7 +

Primeiro instalaremos o módulo de secuela-CLI:

 NPM I -G secuela-cli 

entón Crearemos un cartafol onde contén a nosa aplicación, crearemos un ficheiro JS e instalaremos secuela e o seu dialecto (neste caso MySQL):

MKDIR HowTo -Squeelizar & & CD HowTo-secuela de secuelaTouch Índice.JSNPM INIT -YNPM I -S secuela MySQL2

Agora nós ten que comezar o proxecto con secuela-cli:

 secuela de inicio 

Sequelize-cli creou unha estrutura base na raíz do noso proxecto:

Se revisamos o ficheiro ./config/config.json, vemos que temos 3 opcións de conexión a unha base de datos, Modemos a opción de “desenvolvemento”:

 "Desenvolvemento": {"Nome de usuario": "Root", "Contrasinal": "Tucontraseña", "Base de datos": "HowTo-Sequerize", "Host": "127.0.0.1", "Dialecto": "MySQL" , "OperatorSaliaSE": false, "Dialectoptions": {"Charset": "UTF8MB4"}, "Logging": True, "Benchmark": True} 

Agora revisa o ficheiro ./Models/index. JS. Este ficheiro ten unha función para crear unha nova instancia de secuela cada vez que se chame e ten como unha variable de ambiente predeterminado para “Desenvolvemento”, que usará a base de datos, servidor, usuario, contrasinal e opcións que acaba de engadir.

Cremos que a nosa base de datos co seguinte comando:

 secuela DB: create 

moi bo! Agora imos comezar a crear o noso Modelos:

 Sequelize Model: Xerar - Nome usuario - Contributes Nome: String, Apelido: String, Alaverdom: String, Email: String Sequelize Model: Xerar - - Nome LanguageP --Tributes Nome: String Sequiize Modelo: Xerar --Name USER_LENGUAJEP --TRIBUTUNEUSEROID: Integer, idioma: enteiro 

Despois de crear os nosos modelos ten que facer a relación entre usuarios e idiomas.

./ modelos / user.js

 'use rigoroso'; módule.Exports = (secuela de datos, datatypes) =  {var usuario = seco Lize.Define ('Usuario', {Nome: DatatyPes.String, apelido: Datatypes.String, Alaverdom: Datatypes.String, Correo electrónico: Datatypes.string}, {}); User.associate = Función (modelos) {// As asociacións pódense definir aquí user.belongstomán (modelos.Idioma, {a través de: 'user_lenguajep', como: 'Idiomas, a programación', o estranxeiro: 'UserID',}); Devolver o usuario;}; 

imos analizar isto, vemos que o noso modelo de usuario executa unha función de pertenencia que apunta ao modelo de idioma, en poucas palabras que indicamos que un usuario pode pertencer a varios idiomas. Nas opcións, a través do que indica a táboa para a que ten que cruzar para atopar estas relacións, como é opcional, é o nome da propiedade ou a clave que nos dará estas relacións, a marca estranxeira porque a columna queremos buscar estes relacións.

./ modelos / idianasp.js

 'use rigoroso'; módule.Exports = (secuela de datos, datatypes) =   {var idianp = Sequelize.Define ('Idiganp', {name: Datatypes.string}, {}); LanguageP.Associate = Función (Modelos) {// Asociacións pódese definir aquí idiomap.belongstomany (models.suario, {a través de: 'user_lenguajep', como: 'Usuarios', Basterkey: 'LanguagePid',}; Devolver o idiomap;}; 

Facemos o mesmo coas linguas (linguaxe), pero agora apuntando ao modelo de usuario.

Vexamos un pouco o que falamos, ORM Funciona nunha capa que é o mapeamento (mapeo), estas relacións só se realizarán no proxecto, necesitamos crear unha migración que afecta á base de datos. Hai IRM que revisan se fixeches cambios nos teus modelos e creas novas migracións en función destes cambios (Django Orm, Peewee), no noso caso de secuela de secuela non ten iso, polo que imos crear as nosas migracións:

 Sequelize Migration: Xerar - Nome Relación-Moitos a moitos 

Isto xerou un novo ficheiro cun esqueleto nas nosas migracións, agora temos que modificalo :

 'use rigoroso'; module.exports = {Up: (QueryInterface, sequelize) =  {return, {type: 'FOREIGN KEY', nome: 'FK_USUARIOLEGAJEP_USUARO_1', Referencia: {TABLE: 'Usuario' , Campo: 'ID',}, Ondelete: 'NO Action', Onupdate: 'NO Action',}), QueryInterface.AddconstrAint ('USER_LENGUAJEP' ,, {Tipo: 'KEEY EXTERIOR', Nome: 'FK_USUARIOLEGEGAP_LENGUEP_1', Referencias : {Táboa: 'idianp', campo: 'id',}, ondelete: 'non acción', onpordate: 'non acción',}),]}, abaixo: (queryinterface, secuela) =  {return}}; 

Este ficheiro exporta un obxecto con 2 propiedades, arriba e abaixo. A propiedade encárgase de entregar unha promesa que modifica os datos (crear táboas, relacións, campos, tipos de cambio, etc.) e a propiedade down doutro xeito, reverter os cambios que se fixeron enriba.

moi ben, agora toca a miña parte favorita, ten que executar os scripts de migración co seguinte comando:

 secuela DB: migrar 

Boom! Pero que pasou?!?! Se lemos coidadosamente o erro na consola di que non atopa a táboa USER_Lenguajet na base de datos, revise as táboas. Hai algo curioso, todo o final cun “s”, isto é porque secuela-cli xestiona as placas en plural por defecto, mesmo cando nas nosas opcións temos freezetablename: Verdadeiro, este caso pódese ver aquí.

Entón só necesitamos cambiar o nome das táboas un plural en relación-moitos a moitos (user_lenguajeps, usuarios, idioma).

Desfacer as migracións, mover e voilà
 sequelize db: migrate: Undo: Allsequelize dB: Migrar 

As migracións foron exitosas! Agora temos que poboar estas táboas, secuelar-CLI usa as sementes (sementes). Crearemos 3 ficheiros de sementes:

 Seedelize Seed: Generate - Name UsersLize Seed: Generate - Name LanguagePsequelize Seed: Generate --Name user_lenguajap 

Estas sementes están localizadas no cartafol ./seeders, ten que poñer os datos que Queremos cargar na base de datos.

Semi Todo usuario:

 'use rigoroso'; módule.Exports = {UP: (QueryInterFace, Sequelize) =  {devolveryinterface.bulkinsert ('Usuarios', {}); }, down: (QueryInterFace, secuela) =  {devolveryinterface.bulkdelete ('Usuarios', null, {}); }}; 

Idioma de sementeP:

 'Usar rigoroso'; módule.Exports = {up: (queryinterface, secuela) =  {devolveryinterface.bulkinsert ('idianps', {}); }, down: (QueryInterFace, secuela) =  {devolveryinterface.bulkdelete ('idianps', null, {}); }}; 

Seed user_lenguajep:

 'Usar rigoroso'; MODULE.EXPORTS = {UP: (QueryInterFace, Sequelize) =  {devolveryinterface.bulkinsert ('user_lenguajeps' ,, {}); }, Down: (QueryInterFace, Sequelize) =  {devolve Queryinterface.Bulkdelete ('user_lenguajeps, null, {}); }}; 

Agora ten que cargar estes datos á base de datos co seguinte comando:

 secuela de db: semente: todo 

moi ben! Xa vimos como inicializar un proxecto con secuela, crear modelos, asignar relacións, crear migracións, executar e desfacer as migracións, crear sementes e cargarlas á base de datos, só necesitamos facer consultas. Imos ao noso index.js na raíz e escribe a seguinte función:

 const db = require ('./ modelos'); Const main = async () =  {proba {const usuarios = agardar db.suario.findall ({inclúen:}, a través de: {atributos:},}],}; Console.log (json.stringify (usuarios)); Proceso.exit (); } captura (erro) {console.log (erro); }}; Principal (); 

Gardámolo e executa o programa (por consola ou coa ferramenta de depuración de código Visual Studiu e debemos recibir un JSON cunha lista de usuarios (neste exemplo hai só un) cos seus datos e idiomas:

}] 

aprendemos secuela-cli e os conceptos básicos de secuela, agora podemos crear unha API que executa Accións Crud para que os nosos clientes o consuman!

Deixa unha resposta

O teu enderezo electrónico non se publicará Os campos obrigatorios están marcados con *