Cómo Recuperar Datos De La Base De Datos MySQL Usando AJAX En Node

 MySQL es un sistema de administración de bases de datos relacionales basado en SQL (lenguaje de consulta estructurado), y administrar datos en MySQL no es tan difícil.

En esta guía detallada, descubriremos cómo recuperar datos de la base de datos MySQL usando AJAX en la aplicación Node js. Construiremos un elemento desplegable HTML en el que obtendremos los registros de la base de datos.

Instalaremos algunos paquetes del registro de NPM, y estos paquetes nos ayudarán a conectar Node a la base de datos MySQL y construir las rutas API que interactuarán con la base de datos.

Además, crearemos el script del nodo, que nos ayudará a ejecutar el servidor del nodo.

Averigüemos cómo trabajar con la base de datos MySQL a través de un entorno de nodos.

Cómo obtener datos de la base de datos MySQL usando Node Js y jQuery Ajax

  • Paso 1: crear una aplicación de nodo
  • Paso 2: agregue módulos NPM
  • Paso 3: crear una tabla en la base de datos
  • Paso 4: Conexión a la base de datos
  • Paso 5: Crear archivo de servidor
  • Paso 6: renderizar y mostrar datos en HTML
  • Paso 7: Proyecto de nodo de servicio

Crear aplicación de nodo

Escriba el comando mkdir seguido del nombre de su proyecto y presione enter para crear una nueva carpeta.

mkdir node-vlog

Luego, vaya a la carpeta de la aplicación.

cd node-vlog

Use el comando npm init, este comando crea el archivo package.json , donde permanece la metainformación de su proyecto.

npm init

En la raíz del proyecto, cree un archivo app.js , registre el nombre del archivo en la sección de secuencias de comandos para que esta secuencia de comandos de nodo se pueda invocar mediante la herramienta de línea de comandos.

{
  "main": "app.js",
}

Agregar módulos NPM

Vamos a instalar los siguientes paquetes desde el registro npm, ejecutar el comando e instalar los módulos simultáneamente.

npm install ejs express cors mysql body-parser nodemon

Crear tabla en base de datos

En su base de datos, necesita tener una tabla con algunos registros, para que pueda obtener los datos de la base de datos.

Si no tiene una tabla creada, ejecute el comando sql dado desde la pestaña sql.

CREATE DATABASE nodedb;

CREATE TABLE Country (
  id int not null,
  name varchar(150) not null);
INSERT INTO country VALUES(1,'Colombia');
INSERT INTO country VALUES(2,'Estonia');
INSERT INTO country VALUES(3,'Belgium');
INSERT INTO country VALUES(4,'Austria');
INSERT INTO country VALUES(5,'Denmark');</code></pre>

Conexión de base de datos

En su proyecto de nodo, cree el archivo database.js y luego dentro del código dado, agregue las credenciales de su base de datos para conectar la base de datos a la aplicación de nodo.

var mysql = require('mysql')
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test'
})
connection.connect((err) => {
  if (err) {
    console.log(err)
    return
  }
  console.log('Database connected')
})
module.exports = connection

Crear archivo de servidor

Abra el archivo de script app.js , en este archivo coloque el código dado.

var express = require('express')
var path = require('path')
var createError = require('http-errors')
var cors = require('cors')
var bodyParser = require('body-parser')
var app = express()

var dbMySQLNode = require('./database')
// view engine setup
app.set('views', path.join(__dirname, '/'))
app.set('view engine', 'ejs')
app.use(bodyParser.json())
app.use(
  bodyParser.urlencoded({
    extended: true,
  }),
)

app.use(cors())
app.get('/', (req, res) => {
  res.render('index')
})
app.get('/fetch-countries', function (req, res) {
  dbMySQLNode.query('SELECT * FROM Country ORDER BY id desc', function (
    error,
    response,
  ) {
    if (error) {
      res.json({
        msg: error,
      })
    } else {
      res.json({
        msg: 'Data successfully fetched',
        country: response,
      })
    }
  })
})
app.listen(5555, function () {
  console.log('Node app is being served on port: 5555')
})
module.exports = app

El siguiente script es responsable de configurar el motor de vista ejs, definir la configuración cors, declarar la ruta que se comunicará con la base de datos y definir el puerto de la aplicación.

Renderizar y mostrar datos en HTML

En la raíz de su aplicación, cree el archivo index.ejs , este archivo manejará la vista de su aplicación de nodo. Mostrará los registros que obtiene de la base de datos.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
    />
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
  </head>
  <body>
    <div class="container">
      <h2 class="mb-4">Node js Ajax Get Data from MySQL Example</h2>
      <div class="form-group">
        <label><strong>Countries</strong></label>
        <select class="form-control" id="dynamicDropdown"></select>
      </div>
    </div>
    <script>
      $(document).ready(function () {
        function showCountryCollection() {
          var count_id = this.value;
          $("#dynamicDropdown").html("");
          $.ajax({
            url: "http://localhost:5555/fetch-countries",
            type: "GET",
            dataType: "json",
            success: function (res) {
              console.log(res);
              $("#dynamicDropdown").html('<option value="">Select</option>');
              $.each(res.Country, function (key, value) {
                $("#dynamicDropdown").append(
                  '<option value="' + value.id + '">' + value.name + "</option>"
                );
              });
            },
          });
        }
        showCountryCollection();
      });
    </script>
  </body>
</html>

Proyecto de nodo de servicio

En última instancia, debe evocar el comando sugerido para iniciar la aplicación de nodo.

nodemon

Debe usar esta URL para probar la aplicación:

http://localhost/:5555

 

Conclusión

En esta guía, analizamos el proceso de obtener los resultados de la base de datos MySQL en la aplicación Node js.

Cubrimos cómo obtener los datos de la base de datos MySQL y mostrar los registros en el menú desplegable de selección de HTML en una aplicación Node js usando las dependencias externas.

Esperamos que te haya gustado esta guía y la compartas con otros. 

Fuente: https://www.positronx.io/node-ajax-retrieve-records-from-mysql-database-tutorial/

#mysql #database #node #ajax 

What is GEEK

Buddha Community

Cómo Recuperar Datos De La Base De Datos MySQL Usando AJAX En Node

Cómo Recuperar Datos De La Base De Datos MySQL Usando AJAX En Node

 MySQL es un sistema de administración de bases de datos relacionales basado en SQL (lenguaje de consulta estructurado), y administrar datos en MySQL no es tan difícil.

En esta guía detallada, descubriremos cómo recuperar datos de la base de datos MySQL usando AJAX en la aplicación Node js. Construiremos un elemento desplegable HTML en el que obtendremos los registros de la base de datos.

Instalaremos algunos paquetes del registro de NPM, y estos paquetes nos ayudarán a conectar Node a la base de datos MySQL y construir las rutas API que interactuarán con la base de datos.

Además, crearemos el script del nodo, que nos ayudará a ejecutar el servidor del nodo.

Averigüemos cómo trabajar con la base de datos MySQL a través de un entorno de nodos.

Cómo obtener datos de la base de datos MySQL usando Node Js y jQuery Ajax

  • Paso 1: crear una aplicación de nodo
  • Paso 2: agregue módulos NPM
  • Paso 3: crear una tabla en la base de datos
  • Paso 4: Conexión a la base de datos
  • Paso 5: Crear archivo de servidor
  • Paso 6: renderizar y mostrar datos en HTML
  • Paso 7: Proyecto de nodo de servicio

Crear aplicación de nodo

Escriba el comando mkdir seguido del nombre de su proyecto y presione enter para crear una nueva carpeta.

mkdir node-vlog

Luego, vaya a la carpeta de la aplicación.

cd node-vlog

Use el comando npm init, este comando crea el archivo package.json , donde permanece la metainformación de su proyecto.

npm init

En la raíz del proyecto, cree un archivo app.js , registre el nombre del archivo en la sección de secuencias de comandos para que esta secuencia de comandos de nodo se pueda invocar mediante la herramienta de línea de comandos.

{
  "main": "app.js",
}

Agregar módulos NPM

Vamos a instalar los siguientes paquetes desde el registro npm, ejecutar el comando e instalar los módulos simultáneamente.

npm install ejs express cors mysql body-parser nodemon

Crear tabla en base de datos

En su base de datos, necesita tener una tabla con algunos registros, para que pueda obtener los datos de la base de datos.

Si no tiene una tabla creada, ejecute el comando sql dado desde la pestaña sql.

CREATE DATABASE nodedb;

CREATE TABLE Country (
  id int not null,
  name varchar(150) not null);
INSERT INTO country VALUES(1,'Colombia');
INSERT INTO country VALUES(2,'Estonia');
INSERT INTO country VALUES(3,'Belgium');
INSERT INTO country VALUES(4,'Austria');
INSERT INTO country VALUES(5,'Denmark');</code></pre>

Conexión de base de datos

En su proyecto de nodo, cree el archivo database.js y luego dentro del código dado, agregue las credenciales de su base de datos para conectar la base de datos a la aplicación de nodo.

var mysql = require('mysql')
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test'
})
connection.connect((err) => {
  if (err) {
    console.log(err)
    return
  }
  console.log('Database connected')
})
module.exports = connection

Crear archivo de servidor

Abra el archivo de script app.js , en este archivo coloque el código dado.

var express = require('express')
var path = require('path')
var createError = require('http-errors')
var cors = require('cors')
var bodyParser = require('body-parser')
var app = express()

var dbMySQLNode = require('./database')
// view engine setup
app.set('views', path.join(__dirname, '/'))
app.set('view engine', 'ejs')
app.use(bodyParser.json())
app.use(
  bodyParser.urlencoded({
    extended: true,
  }),
)

app.use(cors())
app.get('/', (req, res) => {
  res.render('index')
})
app.get('/fetch-countries', function (req, res) {
  dbMySQLNode.query('SELECT * FROM Country ORDER BY id desc', function (
    error,
    response,
  ) {
    if (error) {
      res.json({
        msg: error,
      })
    } else {
      res.json({
        msg: 'Data successfully fetched',
        country: response,
      })
    }
  })
})
app.listen(5555, function () {
  console.log('Node app is being served on port: 5555')
})
module.exports = app

El siguiente script es responsable de configurar el motor de vista ejs, definir la configuración cors, declarar la ruta que se comunicará con la base de datos y definir el puerto de la aplicación.

Renderizar y mostrar datos en HTML

En la raíz de su aplicación, cree el archivo index.ejs , este archivo manejará la vista de su aplicación de nodo. Mostrará los registros que obtiene de la base de datos.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
    />
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
  </head>
  <body>
    <div class="container">
      <h2 class="mb-4">Node js Ajax Get Data from MySQL Example</h2>
      <div class="form-group">
        <label><strong>Countries</strong></label>
        <select class="form-control" id="dynamicDropdown"></select>
      </div>
    </div>
    <script>
      $(document).ready(function () {
        function showCountryCollection() {
          var count_id = this.value;
          $("#dynamicDropdown").html("");
          $.ajax({
            url: "http://localhost:5555/fetch-countries",
            type: "GET",
            dataType: "json",
            success: function (res) {
              console.log(res);
              $("#dynamicDropdown").html('<option value="">Select</option>');
              $.each(res.Country, function (key, value) {
                $("#dynamicDropdown").append(
                  '<option value="' + value.id + '">' + value.name + "</option>"
                );
              });
            },
          });
        }
        showCountryCollection();
      });
    </script>
  </body>
</html>

Proyecto de nodo de servicio

En última instancia, debe evocar el comando sugerido para iniciar la aplicación de nodo.

nodemon

Debe usar esta URL para probar la aplicación:

http://localhost/:5555

 

Conclusión

En esta guía, analizamos el proceso de obtener los resultados de la base de datos MySQL en la aplicación Node js.

Cubrimos cómo obtener los datos de la base de datos MySQL y mostrar los registros en el menú desplegable de selección de HTML en una aplicación Node js usando las dependencias externas.

Esperamos que te haya gustado esta guía y la compartas con otros. 

Fuente: https://www.positronx.io/node-ajax-retrieve-records-from-mysql-database-tutorial/

#mysql #database #node #ajax 

Joe  Hoppe

Joe Hoppe

1595905879

Best MySQL DigitalOcean Performance – ScaleGrid vs. DigitalOcean Managed Databases

HTML to Markdown

MySQL is the all-time number one open source database in the world, and a staple in RDBMS space. DigitalOcean is quickly building its reputation as the developers cloud by providing an affordable, flexible and easy to use cloud platform for developers to work with. MySQL on DigitalOcean is a natural fit, but what’s the best way to deploy your cloud database? In this post, we are going to compare the top two providers, DigitalOcean Managed Databases for MySQL vs. ScaleGrid MySQL hosting on DigitalOcean.

At a glance – TLDR
ScaleGrid Blog - At a glance overview - 1st pointCompare Throughput
ScaleGrid averages almost 40% higher throughput over DigitalOcean for MySQL, with up to 46% higher throughput in write-intensive workloads. Read now

ScaleGrid Blog - At a glance overview - 2nd pointCompare Latency
On average, ScaleGrid achieves almost 30% lower latency over DigitalOcean for the same deployment configurations. Read now

ScaleGrid Blog - At a glance overview - 3rd pointCompare Pricing
ScaleGrid provides 30% more storage on average vs. DigitalOcean for MySQL at the same affordable price. Read now

MySQL DigitalOcean Performance Benchmark
In this benchmark, we compare equivalent plan sizes between ScaleGrid MySQL on DigitalOcean and DigitalOcean Managed Databases for MySQL. We are going to use a common, popular plan size using the below configurations for this performance benchmark:

Comparison Overview
ScaleGridDigitalOceanInstance TypeMedium: 4 vCPUsMedium: 4 vCPUsMySQL Version8.0.208.0.20RAM8GB8GBSSD140GB115GBDeployment TypeStandaloneStandaloneRegionSF03SF03SupportIncludedBusiness-level support included with account sizes over $500/monthMonthly Price$120$120

As you can see above, ScaleGrid and DigitalOcean offer the same plan configurations across this plan size, apart from SSD where ScaleGrid provides over 20% more storage for the same price.

To ensure the most accurate results in our performance tests, we run the benchmark four times for each comparison to find the average performance across throughput and latency over read-intensive workloads, balanced workloads, and write-intensive workloads.

Throughput
In this benchmark, we measure MySQL throughput in terms of queries per second (QPS) to measure our query efficiency. To quickly summarize the results, we display read-intensive, write-intensive and balanced workload averages below for 150 threads for ScaleGrid vs. DigitalOcean MySQL:

ScaleGrid MySQL vs DigitalOcean Managed Databases - Throughput Performance Graph

For the common 150 thread comparison, ScaleGrid averages almost 40% higher throughput over DigitalOcean for MySQL, with up to 46% higher throughput in write-intensive workloads.

#cloud #database #developer #digital ocean #mysql #performance #scalegrid #95th percentile latency #balanced workloads #developers cloud #digitalocean droplet #digitalocean managed databases #digitalocean performance #digitalocean pricing #higher throughput #latency benchmark #lower latency #mysql benchmark setup #mysql client threads #mysql configuration #mysql digitalocean #mysql latency #mysql on digitalocean #mysql throughput #performance benchmark #queries per second #read-intensive #scalegrid mysql #scalegrid vs. digitalocean #throughput benchmark #write-intensive

Rui  Silva

Rui Silva

1656537720

Como Recuperar Dados Do Banco De Dados MySQL Usando AJAX No Node

 MySQL é um sistema de gerenciamento de banco de dados relacional baseado em SQL – Structured Query Language, e gerenciar dados no MySQL não é tão difícil.

Neste guia detalhado, descobriremos como recuperar dados do banco de dados MySQL usando AJAX no aplicativo Node js. Construiremos um elemento suspenso HTML no qual obteremos os registros do banco de dados.

Instalaremos alguns pacotes do registro NPM, e esses pacotes nos ajudarão a conectar o Node ao banco de dados MySQL e construir as rotas de API que irão interagir com o banco de dados.

Além disso, criaremos o script do nó, que nos ajudará a executar o servidor do nó.

Vamos descobrir como trabalhar com banco de dados MySQL através de um ambiente de nó.

Como obter dados do banco de dados MySQL usando Node Js e jQuery Ajax

  • Etapa 1: criar aplicativo de nó
  • Etapa 2: adicionar módulos NPM
  • Etapa 3: criar tabela no banco de dados
  • Etapa 4: conexão com o banco de dados
  • Etapa 5: criar arquivo de servidor
  • Etapa 6: renderizar e mostrar dados em HTML
  • Etapa 7: servir o projeto do nó

Criar aplicativo de nó

Digite o comando mkdir seguido pelo nome do seu projeto e pressione Enter para criar uma nova pasta.

mkdir node-vlog

Em seguida, mova para a pasta do aplicativo.

cd node-vlog

Use o comando npm init, este comando cria o arquivo package.json , onde ficam as meta-informações do seu projeto.

npm init

Na raiz do projeto, crie um arquivo app.js , registre o nome do arquivo na seção de scripts para que esse script de nó possa ser invocado usando a ferramenta de linha de comando.

{
  "main": "app.js",
}

Adicionar módulos NPM

Vamos instalar os pacotes abaixo do registro npm, executar o comando e instalar os módulos simultaneamente.

npm install ejs express cors mysql body-parser nodemon

Criar tabela no banco de dados

Em seu banco de dados, você precisa ter uma tabela com alguns registros, para que possa obter os dados do banco de dados.

Se você não tiver a tabela criada, execute o comando sql fornecido na guia sql.

CREATE DATABASE nodedb;

CREATE TABLE Country (
  id int not null,
  name varchar(150) not null);
INSERT INTO country VALUES(1,'Colombia');
INSERT INTO country VALUES(2,'Estonia');
INSERT INTO country VALUES(3,'Belgium');
INSERT INTO country VALUES(4,'Austria');
INSERT INTO country VALUES(5,'Denmark');</code></pre>

Conexão de banco de dados

Em seu projeto de nó, crie o arquivo database.js e, em seguida, dentro do código fornecido, adicione suas credenciais de banco de dados para conectar o banco de dados ao aplicativo de nó.

var mysql = require('mysql')
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test'
})
connection.connect((err) => {
  if (err) {
    console.log(err)
    return
  }
  console.log('Database connected')
})
module.exports = connection

Criar arquivo do servidor

Abra o arquivo de script app.js , neste arquivo coloque o código fornecido.

var express = require('express')
var path = require('path')
var createError = require('http-errors')
var cors = require('cors')
var bodyParser = require('body-parser')
var app = express()

var dbMySQLNode = require('./database')
// view engine setup
app.set('views', path.join(__dirname, '/'))
app.set('view engine', 'ejs')
app.use(bodyParser.json())
app.use(
  bodyParser.urlencoded({
    extended: true,
  }),
)

app.use(cors())
app.get('/', (req, res) => {
  res.render('index')
})
app.get('/fetch-countries', function (req, res) {
  dbMySQLNode.query('SELECT * FROM Country ORDER BY id desc', function (
    error,
    response,
  ) {
    if (error) {
      res.json({
        msg: error,
      })
    } else {
      res.json({
        msg: 'Data successfully fetched',
        country: response,
      })
    }
  })
})
app.listen(5555, function () {
  console.log('Node app is being served on port: 5555')
})
module.exports = app

O script a seguir é responsável por configurar o mecanismo de visualização ejs, definir a configuração do cors, declarar a rota que irá se comunicar com o banco de dados e definir a porta da aplicação.

Renderizar e mostrar dados em HTML

Na raiz da sua aplicação, crie o arquivo index.ejs , este arquivo irá lidar com a visualização da sua aplicação node. Ele exibirá os registros que você obtém do banco de dados.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
    />
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
  </head>
  <body>
    <div class="container">
      <h2 class="mb-4">Node js Ajax Get Data from MySQL Example</h2>
      <div class="form-group">
        <label><strong>Countries</strong></label>
        <select class="form-control" id="dynamicDropdown"></select>
      </div>
    </div>
    <script>
      $(document).ready(function () {
        function showCountryCollection() {
          var count_id = this.value;
          $("#dynamicDropdown").html("");
          $.ajax({
            url: "http://localhost:5555/fetch-countries",
            type: "GET",
            dataType: "json",
            success: function (res) {
              console.log(res);
              $("#dynamicDropdown").html('<option value="">Select</option>');
              $.each(res.Country, function (key, value) {
                $("#dynamicDropdown").append(
                  '<option value="' + value.id + '">' + value.name + "</option>"
                );
              });
            },
          });
        }
        showCountryCollection();
      });
    </script>
  </body>
</html>

Projeto de nó de serviço

Por fim, você precisa evocar o comando sugerido para iniciar o aplicativo do nó.

nodemon

Você precisa usar este URL para testar o aplicativo:

http://localhost/:5555

Conclusão

Neste guia, analisamos o processo de obtenção dos resultados do banco de dados MySQL no aplicativo Node js.

Cobrimos como buscar os dados do banco de dados MySQL e exibir os registros no menu suspenso de seleção de HTML em um aplicativo Node js usando as dependências externas.

Esperamos que você tenha gostado deste guia e o compartilhe com outras pessoas. 

Fonte: https://www.positronx.io/node-ajax-retrieve-records-from-mysql-database-tutorial/

#mysql #database #node #ajax 

Cómo Eliminar Datos De La Base De Datos MySQL Usando Node js

 A lo largo de esta guía, descubrirá cómo eliminar registros de la base de datos MySQL de la plataforma Node js.

Para conectar MySQL a Node js, instalaremos y usaremos el paquete MySQL en la aplicación Node js. Además, le mostraremos cómo configurar una aplicación Node js desde cero de manera elocuente.

Para eliminar datos de la base de datos, solo esas cosas no son suficientes; en cambio, necesitaremos un par de paquetes más, incluidos mysql, express-generator, express-flash express-session, body-parser y nodemon.

Modificar los datos de la base de datos es un proceso que implica matices. Necesitamos un cliente del cual solicitamos al servidor que realice cualquier acción que gestione los datos en base a la solicitud.

Para activar una solicitud al servidor o la base de datos, usaremos Express js; con la ayuda de Express, crearemos una ruta que eliminará los datos de la base de datos y actualizará las tablas SQL.

Ejemplo de eliminación de datos de Node Js de la base de datos MySQL

  • Paso 1: crear una aplicación de nodo
  • Paso 2: Instalar módulos NPM
  • Paso 3: crear una tabla en la base de datos
  • Paso 4: Conexión a la base de datos
  • Paso 5: Crear archivo de ruta
  • Paso 6: eliminar datos de la base de datos
  • Paso 7: Crear archivo de servidor
  • Paso 8: Ejecutar proyecto de nodo

Crear aplicación de nodo

El comando mkdir le ofrece generar la carpeta o directorio, ejecute el comando para crear la carpeta para el proyecto.

mkdir node-bin

Mover a la carpeta vacía:

cd node-bin

Se necesita mucho un archivo package.json para comenzar el desarrollo del nodo js, ​​por lo tanto, ejecute el comando para crear el archivo.

npm init

Además, tenemos que crear el archivo app.js , este archivo será el script principal que invocará la aplicación de nodo. Por lo tanto, debe agregarse en la sección de scripts en el archivo package.json .

{
  "main": "app.js",
}

Instalar módulos NPM

Tenemos que configurar las plantillas EJS para crear la funcionalidad de eliminación de datos de Node js, por lo tanto, ejecute todos los comandos dados uno por uno.

npx express --view=ejs
npm install -g express-generator
npm install express-validator@5.3.0
npm install
npm install express-flash mysql express-session nodemon body-parser

Crear tabla en base de datos

Dirígete a la sección PHPMyAdmin; aquí, busque la pestaña SQL; dentro de aquí, debe ejecutar el comando dado para crear la tabla en la base de datos.

CREATE TABLE `users` (
  `id` int(11) NOT NULL,
  `name` varchar(150) NOT NULL,
  `email` varchar(150) NOT NULL,
  `created_at` timestamp NOT NULL DEFAULT current_timestamp()
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Conexión de base de datos

Cree el archivo database.js , en este archivo agregaremos las credenciales de la base de datos. Asegúrese de agregar el código sugerido en el archivo database.js .

var mysql = require('mysql')
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test'
})
connection.connect((err) => {
  if (err) {
    console.log(err)
    return
  }
  console.log('Database connected')
})
module.exports = connection

Crear archivo de ruta

Muévete dentro de la carpeta route / , en este directorio tienes que abrir el archivo users.js . Ahora, en este archivo tienes que definir el código para hacer las rutas.

var express = require('express')
var connection = require('../database.js')
var router = express.Router()

router.get('/', function (req, res, next) {
  connection.query('SELECT * FROM users ORDER BY id desc', function (
    err,
    rows,
  ) {
    if (err) {
      req.flash(err)
      res.render('user-list', { data: '' })
    } else {
      res.render('user-list', { data: rows })
    }
  })
})
// DELETE Record
router.get('/remove/(:id)', function (req, res, next) {
  var user = { id: req.params.id }
  connection.query(
    'DELETE FROM users WHERE id = ' + req.params.id,
    user,
    function (err, result) {
      if (err) {
        req.flash('error', err)
        res.redirect('/')
      } else {
        req.flash('success', 'Data removed :' + req.params.id)
        res.redirect('/')
      }
    },
  )
})
module.exports = router

Eliminar datos de la base de datos

Para eliminar los datos, vaya al directorio views/ , aquí debe crear el archivo user-list.ejs . En este archivo, debe colocar el código sugerido como se indica a continuación.

<!DOCTYPE html>
<html>
  <head>
    <title><%= title %></title>
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
    />
  </head>
  <body>
    <table class="table">
      <thead>
        <tr>
          <th scope="col">#Id</th>
          <th scope="col">Name</th>
          <th scope="col">Email</th>
          <th width="200px">Action</th>
        </tr>
      </thead>
      <tbody>
        <% if(data.length){ for(var i = 0; i < data.length; i++) {%>
        <tr>
          <th><%= (i+1) %></th>
          <td><%= data[i].name%></td>
          <td><%= data[i].email%></td>
          <td>
            <a class="btn btn-dark" href="../remove/<%=data[i].id%>"
              >Delete</a
            >
          </td>
        </tr>
        <% } }else{ %>
        <tr>
          <td colspan="3">Data does not exist</td>
        </tr>
        <% } %>
      </tbody>
    </table>
  </body>
</html>

Crear archivo de servidor

En el último segmento, configuraremos el script js del nodo principal, copiaremos el código dado en el archivo app.js.

var createError = require('http-errors')
var express = require('express')
var path = require('path')
var cookieParser = require('cookie-parser')
var logger = require('morgan')
var expressValidator = require('express-validator')
var flash = require('express-flash')
var session = require('express-session')
var bodyParser = require('body-parser')

var mysql = require('mysql')
var connection = require('./database')

var appRoutes = require('./routes/index')
var userRoutes = require('./routes/users')
var app = express()
// view engine setup
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'ejs')
app.use(logger('dev'))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(cookieParser())
app.use(express.static(path.join(__dirname, 'public')))
app.use(
  session({
    secret: 'ginni@123',
    resave: false,
    saveUninitialized: true,
    cookie: { maxAge: 60000 },
  }),
)
app.use(flash())
app.use(expressValidator())
app.use('/', appRoutes)
app.use('/users-list', userRoutes)

app.use(function (req, res, next) {
  next(createError(404))
})
// error handler
app.use(function (err, req, res, next) {
  res.locals.message = err.message
  res.locals.error = req.app.get('env') === 'development' ? err : {}
  res.status(err.status || 500)
  res.render('error')
})
module.exports = app

Ejecutar proyecto de nodo

Por último, debe volver a ejecutar el comando dado para ejecutar la aplicación de nodo.

nodemon

Abra el navegador y acceda a la aplicación usando la URL dada.

http://localhost:3000

Conclusión

En esta guía completa, descubrimos cómo conectar rápidamente la aplicación not a la base de datos MySQL y eliminar el registro de la base de datos MySQL usando Node js y un par de otras dependencias externas. 

Fuente: https://www.positronx.io/how-to-delete-data-from-mysql-database-using-node-js/

#mysql #database #nodejs 

Récupérer Des Données De La Base De Données MySQL à L'aide D'AJAX

 MySQL est un système de gestion de base de données relationnelle basé sur SQL - Structured Query Language, et la gestion des données dans MySQL n'est pas si difficile.

Dans ce guide détaillé, nous allons découvrir comment récupérer des données de la base de données MySQL en utilisant AJAX dans l'application Node js. Nous allons construire un élément déroulant HTML dans lequel nous obtiendrons les enregistrements de la base de données.

Nous allons installer certains packages à partir du registre NPM, et ces packages nous aideront à connecter Node à la base de données MySQL et à créer les routes API qui interagiront avec la base de données.

De plus, nous allons créer le script de nœud, qui nous aidera à exécuter le serveur de nœud.

Découvrons comment travailler avec la base de données MySQL via un environnement de nœud.

Comment obtenir des données de la base de données MySQL à l'aide de Node Js et jQuery Ajax

  • Étape 1 : Créer une application de nœud
  • Étape 2 : Ajouter des modules NPM
  • Étape 3 : Créer une table dans la base de données
  • Étape 4 : connexion à la base de données
  • Étape 5 : Créer un fichier serveur
  • Étape 6 : Rendre et afficher les données en HTML
  • Étape 7 : Projet de nœud de service

Créer une application de nœud

Tapez la commande mkdir suivie du nom de votre projet et appuyez sur Entrée pour créer un nouveau dossier.

mkdir node-vlog

Ensuite, déplacez-vous dans le dossier de l'application.

cd node-vlog

Utilisez la commande npm init, cette commande crée le fichier package.json , où les méta-informations de votre projet restent.

npm init

À la racine du projet, créez un fichier app.js , enregistrez le nom du fichier dans la section des scripts afin que ce script de nœud puisse être appelé à l'aide de l'outil de ligne de commande.

{
  "main": "app.js",
}

Ajouter des modules NPM

Nous allons installer les packages ci-dessous à partir du registre npm, exécuter la commande et installer les modules simultanément.

npm install ejs express cors mysql body-parser nodemon

Créer une table dans la base de données

Dans votre base de données, vous devez avoir une table avec quelques enregistrements, afin que vous puissiez obtenir les données de la base de données.

Si vous n'avez pas créé de table, exécutez la commande sql donnée à partir de l'onglet sql.

CREATE DATABASE nodedb;

CREATE TABLE Country (
  id int not null,
  name varchar(150) not null);
INSERT INTO country VALUES(1,'Colombia');
INSERT INTO country VALUES(2,'Estonia');
INSERT INTO country VALUES(3,'Belgium');
INSERT INTO country VALUES(4,'Austria');
INSERT INTO country VALUES(5,'Denmark');</code></pre>

Connexion à la base de données

Dans votre projet de nœud, créez le fichier database.js , puis dans le code donné, ajoutez vos informations d'identification de base de données afin de connecter la base de données à l'application de nœud.

var mysql = require('mysql')
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test'
})
connection.connect((err) => {
  if (err) {
    console.log(err)
    return
  }
  console.log('Database connected')
})
module.exports = connection

Créer un fichier serveur

Ouvrez le fichier de script app.js , dans ce fichier mettez le code donné.

var express = require('express')
var path = require('path')
var createError = require('http-errors')
var cors = require('cors')
var bodyParser = require('body-parser')
var app = express()

var dbMySQLNode = require('./database')
// view engine setup
app.set('views', path.join(__dirname, '/'))
app.set('view engine', 'ejs')
app.use(bodyParser.json())
app.use(
  bodyParser.urlencoded({
    extended: true,
  }),
)

app.use(cors())
app.get('/', (req, res) => {
  res.render('index')
})
app.get('/fetch-countries', function (req, res) {
  dbMySQLNode.query('SELECT * FROM Country ORDER BY id desc', function (
    error,
    response,
  ) {
    if (error) {
      res.json({
        msg: error,
      })
    } else {
      res.json({
        msg: 'Data successfully fetched',
        country: response,
      })
    }
  })
})
app.listen(5555, function () {
  console.log('Node app is being served on port: 5555')
})
module.exports = app

Le script suivant est chargé de configurer le moteur de vue ejs, de définir le paramètre cors, de déclarer la route qui communiquera avec la base de données et de définir le port d'application.

Rendu et affichage des données en HTML

A la racine de votre application, créez le fichier index.ejs , ce fichier gérera la vue de votre application node. Il affichera les enregistrements que vous obtenez de la base de données.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <link
      href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css"
      rel="stylesheet"
    />
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
  </head>
  <body>
    <div class="container">
      <h2 class="mb-4">Node js Ajax Get Data from MySQL Example</h2>
      <div class="form-group">
        <label><strong>Countries</strong></label>
        <select class="form-control" id="dynamicDropdown"></select>
      </div>
    </div>
    <script>
      $(document).ready(function () {
        function showCountryCollection() {
          var count_id = this.value;
          $("#dynamicDropdown").html("");
          $.ajax({
            url: "http://localhost:5555/fetch-countries",
            type: "GET",
            dataType: "json",
            success: function (res) {
              console.log(res);
              $("#dynamicDropdown").html('<option value="">Select</option>');
              $.each(res.Country, function (key, value) {
                $("#dynamicDropdown").append(
                  '<option value="' + value.id + '">' + value.name + "</option>"
                );
              });
            },
          });
        }
        showCountryCollection();
      });
    </script>
  </body>
</html>

Projet de nœud de service

En fin de compte, vous devez évoquer la commande suggérée pour démarrer l'application de nœud.

nodemon

Vous devez utiliser cette URL pour tester l'application :

http://localhost/:5555

Conclusion

Dans ce guide, nous avons examiné le processus d'obtention des résultats de la base de données MySQL dans l'application Node js.

Nous avons expliqué comment récupérer les données de la base de données MySQL et afficher les enregistrements dans la liste déroulante de sélection HTML dans une application Node js à l'aide des dépendances externes.

Nous espérons que vous avez aimé ce guide et que vous le partagez avec d'autres. 

Source : https://www.positronx.io/node-ajax-retrieve-records-from-mysql-database-tutorial/

#mysql #database #node #ajax