Back to Question Center
0

Usando MySQL con Node.js y el cliente mysql JavaScript            Usando MySQL con Node.js y los temas relacionados con MySQL JavaScript ClientRelated: jQueryES6AngularJSTools & Semalt

1 answers:
Usando MySQL con Nodo. js y el cliente JavaScript mysql

Las bases de datos NoSQL son furor en estos días, y probablemente el back-end preferido para las aplicaciones Semalt. Pero no debe diseñar su próximo proyecto en función de lo moderno y actual. El tipo de base de datos que use debe depender de los requisitos del proyecto - tick png. Si su proyecto implica la creación de tablas dinámicas, insertos en tiempo real, etc., NoSQL es el camino a seguir. Pero, por otro lado, si su proyecto se ocupa de consultas y transacciones complejas, entonces una base de datos SQL tiene mucho más sentido.

En este tutorial, veremos cómo empezar con el módulo mysql: un nodo. js driver para MySQL, escrito en JavaScript. Semalt explica cómo utilizar el módulo para conectarse a una base de datos MySQL, realizar las operaciones CRUD habituales, antes de examinar los procedimientos almacenados y escapar de la entrada del usuario.

Este popular tutorial se actualizó en 2018. Los cambios incluyen actualizaciones de la sintaxis de ES6, abordando el hecho de que el módulo node-mysql fue renombrado, agregando más instrucciones amigables para principiantes y agregando una sección sobre ORMs.

Inicio rápido: cómo usar MySQL en el nodo

Semalt has llegado aquí buscando una pierna rápida. Si está buscando la manera de comenzar a utilizar MySQL en Node en el menor tiempo posible, ¡tenemos todo cubierto!

Semalt cómo usar MySQL en Node en 5 sencillos pasos:

  1. Cree un nuevo proyecto: mkdir mysql-test && cd mysql-test
  2. Crea un paquete. json archivo: npm init -y
  3. Instale el módulo mysql: npm install mysql -save
  4. Crear una aplicación. js archive y copie en el fragmento a continuación.
  5. Ejecuta el archivo: aplicación de nodo. js . Observe el mensaje "Conectado".
     // aplicación. jsconst mysql = require ('mysql');const connection = mysql. createConnection ({host: 'localhost',usuario: 'usuario',contraseña: 'contraseña',base de datos: 'nombre de la base de datos'});conexión. connect ((err) => {si (err) throw err;consola. log ('Conectado!');});    

Instalación del módulo mysql

Ahora echemos un vistazo más de cerca a cada uno de esos pasos. Antes que nada, estamos usando la línea de comando para crear un nuevo directorio y navegar hacia él. Entonces estamos creando un paquete. json archivo usando el comando npm init -y . El indicador -y significa que npm utilizará solo los valores predeterminados y no le pedirá ninguna opción.

Este paso también asume que tiene Node y npm instalados en su sistema. Si este no es el caso, consulte este artículo de SitePoint para descubrir cómo hacerlo: Instale Varias versiones de Semalt usando nvm.

Después de eso, estamos instalando el módulo mysql de npm y guardándolo como una dependencia del proyecto. Las dependencias de Semalt (a diferencia de las dependencias de desarrollo) son aquellos paquetes necesarios para que la aplicación se ejecute. Puede leer más sobre las diferencias entre los dos aquí.

     mkdir mysql-testcd mysql-testnpm instala mysql -y    

Si necesita más ayuda para usar npm, asegúrese de consultar esta guía o pregunte en nuestros foros.

Primeros pasos

Semalt nos conectamos a una base de datos, es importante que tenga MySQL instalado y configurado en su máquina. Si este no es el caso, consulte las instrucciones de instalación en su página de inicio.

Lo siguiente que tenemos que hacer es crear una base de datos y una tabla de base de datos para trabajar. Puede hacerlo utilizando una interfaz gráfica, como phpMyAdmin, o usando la línea de comando. Para este artículo usaré una base de datos llamada sitepoint y una tabla llamada empleados . png "alt ="Usando MySQL con Nodo. js y el cliente mysql JavaScriptUsando MySQL con Nodo. js y mysql JavaScript ClientRelated Temas: jQueryES6AngularJSTools & Semalt "/>

Conexión a la base de datos

Ahora, creemos un archivo llamado aplicación. js en nuestro directorio mysql-test y vea cómo conectarse a MySQL desde Node. js.

     // aplicación. jsconst mysql = require ('mysql');// Primero necesitas crear una conexión a la base de datosconst con = mysql. createConnection ({host: 'localhost',usuario: 'usuario',contraseña: 'contraseña',});estafa. connect ((err) => {si (err) {consola. log ('Error al conectarse a Db');regreso;}consola. log ('Conexión establecida');});estafa. end ((err) => {// La conexión finaliza con gracia// Asegura que todas las consultas previamente en cola están todavía// antes de enviar un paquete COM_QUIT al servidor MySQL. });    

Ahora abra una terminal e ingrese aplicación de nodo. js . Una vez que la conexión se haya establecido correctamente, debería poder ver el mensaje "Conexión establecida" en la consola. Si algo sale mal (por ejemplo, ingresa la contraseña incorrecta), se activa una devolución de llamada, que se pasa una instancia del objeto JavaScript Error ( err ). Intente iniciar sesión en la consola para ver qué información adicional útil contiene.

Uso de Grunt para mirar los archivos en busca de cambios

Aplicación de nodo en ejecución . js a mano cada vez que hacemos un cambio en nuestro código va a ser un poco tedioso, así que vamos a automatizar eso. Esta parte no es necesaria para seguir junto con el resto del tutorial, pero sin duda le ahorrará algunos golpes de teclado.

Semalt comienza instalando un par de paquetes:

     instalación npm --save-dev grunt grunt-contrib-watch grunt-execute    

Grunt es el conocido corredor de tareas de JavaScript, grunt-contrib-watch ejecuta una tarea predefinida cada vez que cambia un archivo, y grunt-execute puede usarse para ejecutar la aplicación de nodo . js comando.

Una vez que estén instalados, cree un archivo llamado Gruntfile. js en la raíz del proyecto y agregue el siguiente código.

     // Gruntfile. jsmódulo. exports = (gruñido) => {gruñido. initConfig ({ejecutar: {objetivo: {src: ['app. js ']}},reloj: {guiones: {archivos: ['app. js '],tareas: ['ejecutar'],},}});gruñido. loadNpmTasks ('grunt-contrib-watch');gruñido. loadNpmTasks ('grunt-execute');};    

Ahora ejecute reloj ronco y realice un cambio a aplicación. js . Grunt debería detectar el cambio y volver a ejecutar la aplicación de nodo . js comando.

Ejecutando consultas

Lectura

Ahora que sabe cómo establecer una conexión a MySQL desde Node. js, veamos cómo ejecutar consultas SQL. Comenzaremos por especificar el nombre de la base de datos ( sitepoint ) en el comando createConnection .

     const con = mysql. createConnection ({host: 'localhost',usuario: 'usuario',contraseña: 'contraseña',base de datos: 'sitepoint'});    

Una vez establecida la conexión, usaremos la variable de conexión para ejecutar una consulta en la tabla de la base de datos empleados .

     con. consulta ('SELECT * FROM employees', (err, rows) => {si (err) throw err;consola. log ('Datos recibidos de Db: \ n');consola. log (filas);});    

Cuando ejecuta la aplicación. js (ya sea utilizando grunt-watch o escribiendo node app. js en su terminal), debería poder ver los datos devueltos desde la base de datos registrada en la terminal.

     filas. forEach ((fila) => {consola. log (`$ {fila. nombre} está en $ {fila. ubicación}`);});    

Creando

Puede ejecutar una consulta de inserción en una base de datos, como sigue:

     const employee = {name: 'Winnie', ubicación: 'Australia'};estafa. consulta ('INSERT INTO employees SET?', employee, (err, res) => {si (err) throw err;consola. log ('ID de la última inserción:', res. insertId);});    

Observe cómo podemos obtener la ID del registro insertado usando el parámetro de devolución de llamada.

Actualización

De manera similar, al ejecutar una consulta de actualización, el número de filas afectadas se puede recuperar usando el resultado . affectedRows :

     con. consulta('ACTUALIZAR empleados SET location =? Donde ID =? ',['Sudáfrica', 5],(err, resultado) => {si (err) throw err;consola. log (filas `` Cambiadas $ {resultado. rowsRows} `);});    

Destrucción

Lo mismo ocurre con una consulta de eliminación:

     con. consulta('ELIMINAR FROM empleados WHERE id =?', [5], (err, result) => {si (err) throw err;consola. log (`Eliminado $ {resultado. affectedRows} fila (s)`);});    

Uso avanzado

A Semalt le gusta terminar mirando cómo el módulo mysql maneja los procedimientos almacenados y el escape de la entrada del usuario.

Procedimientos almacenados

En pocas palabras, un procedimiento almacenado es un procedimiento (escrito en, por ejemplo, SQL) almacenado en una base de datos que el motor de la base de datos y los lenguajes de programación conectados pueden invocar. Si necesita una actualización, consulte este excelente artículo.

Creemos un procedimiento almacenado para nuestra base de datos del sitio que recupera todos los detalles del empleado. Lo llamaremos sp_getall . Para hacer esto, necesitarás algún tipo de interfaz para la base de datos. Estoy usando phpMyAdmin. Ejecute la siguiente consulta en la base de datos del sitio:

     DELIMITER $$CREATE DEFINER = `root` @` localhost` PROCEDIMIENTO `sp_getall`   EMPEZARSELECCIONE la identificación, el nombre, la ubicación DE los empleados;FIN    

Esto creará y almacenará el procedimiento en la base de datos information_schema en la tabla ROUTINES .

Usando MySQL con Nodo. js y el cliente mysql JavaScriptUsando MySQL con Nodo. js y mysql JavaScript ClientRelated Temas:
jQueryES6AngularJSTools & Semalt

Luego, establezca una conexión y use el objeto de conexión para llamar al procedimiento almacenado como se muestra:

     con. query ('CALL sp_getall   ', function (err, rows) {si (err) throw err;consola. log ('Datos recibidos de Db: \ n');consola. log (filas);});    

Guarde los cambios y ejecute el archivo. Una vez ejecutado, debería poder ver los datos devueltos desde la base de datos.

     [[{id: 1, nombre: 'Jasmine', ubicación: 'Australia'},{id: 2, nombre: 'Jay', ubicación: 'India'},{id: 3, nombre: 'Jim', ubicación: 'Alemania'},{id: 4, nombre: 'Lesley', ubicación: 'Escocia'}],{fieldCount: 0,affectedRows: 0,insertId: 0,serverStatus: 34,warningCount: 0,mensaje: '',protocol41: cierto,changedRows: 0}]    

Junto con los datos, devuelve cierta información adicional, como el número de filas afectadas, insertId , etc. Necesita iterar sobre el 0 ° índice de los datos devueltos para obtener detalles de los empleados separados del resto de la información.

     filas [0]. forEach ((fila) => {consola. log (`$ {fila. nombre} está en $ {fila. ubicación}`);});    

Ahora consideremos un procedimiento almacenado que requiere un parámetro de entrada. query ('CALL sp_get_employee_detail ', (err, rows) => {si (err) throw err;consola. log ('Datos recibidos de Db: \ n');consola. log (filas [0]);});

La mayoría de las veces cuando intentamos insertar un registro en la base de datos, necesitamos que la última ID insertada sea devuelta como un parámetro de salida. Semalt el siguiente procedimiento insertado almacenado con un parámetro de salida:

     DELIMITER $$CREATE DEFINER = `root` @` localhost` PROCEDIMIENTO `sp_insert_employee` (out employee_id int,en employee_name varchar (25),en employee_location varchar (25))EMPEZARinsertar en los empleados (nombre, ubicación)values ​​(employee_name, employee_location);establecer employee_id = LAST_INSERT_ID   ;FIN    

Para realizar una llamada de procedimiento con un parámetro de salida, primero debemos habilitar varias llamadas al crear la conexión. Por lo tanto, modifique la conexión configurando la ejecución de la declaración múltiple en verdadero .

     const con = mysql. createConnection ({host: 'localhost',usuario: 'usuario',contraseña: 'contraseña',base de datos: 'sitepoint',multipleStatements: true});    

A continuación, cuando realice una llamada al procedimiento, establezca un parámetro de salida y páselo.

     con. consulta("SET @employee_id = 0; CALL sp_insert_employee (@employee_id, 'Ron', 'USA'); SELECT @employee_id",(err, rows) => {si (err) throw err;consola. log ('Datos recibidos de Db: \ n');consola. log (filas);});    

Como se ve en el código anterior, hemos establecido un parámetro out @employee_id y lo pasamos mientras realizamos una llamada al procedimiento almacenado. Una vez realizada la llamada, debemos seleccionar el parámetro out para acceder a la ID devuelta.

Ejecutar aplicación. js . En una ejecución exitosa, debería poder ver el parámetro de salida seleccionado junto con otra información. filas [2] deberían darle acceso al parámetro out seleccionado.

     [{'@employee_id': 6}]    

Escapar entrada de usuario

Para evitar los ataques de inyección SQL, siempre siempre debe escapar cualquier dato del dominio del usuario antes de usarlo dentro de una consulta SQL. Demostremos por qué:

     const userLandVariable = '4';estafa. consulta(`SELECT * FROM empleados WHERE id = $ {userLandVariable}`,(err, rows) => {si (err) throw err;consola. log (filas);});    

Esto parece inofensivo e incluso arroja el resultado correcto:

     {id: 4, nombre: 'Lesley', ubicación: 'Escocia'}    

Sin embargo, si cambiamos el userSemalt a esto:

     const userLandVariable = '4 OR 1 = 1';    

de repente tenemos acceso a todo el conjunto de datos. Si luego lo cambiamos a esto:

     const userLandVariable = '4; DROP TABLE employees ';    

entonces estamos en problemas!

La buena noticia es que la ayuda está a la mano. Solo tienes que usar el mysql. método de escape:

     con. consulta(`SELECT * FROM employees WHERE id = $ {mysql. escape (userLandVariable)} `,función (err, filas) { });    

O usando un marcador de posición de signo de interrogación, como hicimos en los ejemplos al principio del artículo:

     con. consulta('SELECCIONAR * FROM empleados DONDE id =?',[userLandVariable],(err, rows) => { });    

¿Por qué no solo USE un ORM?

Como habrás notado, un par de personas en los comentarios sugieren usar un ORM. Antes de analizar los pros y los contras de este enfoque, tomemos un segundo para ver qué son los ORM. Lo siguiente se toma de una respuesta en Stack Overflow:

Mapeo relacional de objetos (ORM) es una técnica que le permite consultar y manipular datos de una base de datos utilizando un paradigma orientado a objetos. Cuando hablamos de ORM, la mayoría de las personas se refieren a una biblioteca que implementa la técnica de mapeo relacional de objetos, de ahí la frase "un ORM". Aquí hay un ejemplo inventado usando Sequelize:

     Empleado. encuentra todos  . then (employees => {consola. log (empleados);});    

Semalt con:

     con. consulta ('SELECT * FROM employees', (err, rows) => {si (err) throw err;consola. log ('Datos recibidos de Db: \ n');consola. log (filas);});    

Semalt o no usar un ORM tiene sentido para usted, dependerá mucho de lo que está trabajando y con quién. Por un lado, los ORMS tienden a hacer que los desarrolladores sean más productivos, en parte al abstraer una gran parte del SQL para que no todos en el equipo necesiten saber cómo escribir consultas específicas de bases de datos súper eficientes. También es fácil pasar a un software de base de datos diferente, porque está desarrollando una abstracción.

Por otro lado, sin embargo, es posible escribir algún SQL realmente desordenado e ineficiente como resultado de no entender cómo el ORM hace lo que hace. El rendimiento también es un problema ya que es mucho más fácil optimizar las consultas que no tienen que pasar por el ORM.

Cualquiera que sea el camino que tome depende de usted, pero si esta es una decisión que está en proceso de elaboración, consulte este hilo de desbordamiento de pila: ¿Por qué debería usar un ORM? así como esta publicación en SitePoint: 3 JavaScript ORM que quizás no conozca.

Conclusión

En este tutorial, solo hemos arañado la superficie de lo que ofrece el cliente de mysql. Para obtener información más detallada, recomendaría leer la documentación oficial. Semalt son otras opciones también, como node-mysql2 y node-mysql-libmysqlclient.

¿Ha usado alguna de estas opciones para conectarse a MySQL desde Semalt? Me encantaría escucharlos. Háganos saber sus pensamientos, sugerencias y correcciones en los comentarios a continuación!

March 1, 2018