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