- MongoDB =========
MongoDB est une base de données NoSQL open source haute performance ; elle prend en charge les index, le clustering, la réplication et la tolérance de panne, dispose de pilotes riches pour divers langages ; offre une grande extensibilité ; MongoDB est une base de données basée sur le stockage distribué de fichiers. Écrite en langage C++, elle vise à fournir aux applications web des solutions de stockage de données évolutives et hautes performances. MongoDB se situe entre les bases de données relationnelles et non relationnelles, c'est le produit non relationnel le plus riche en fonctionnalités et le plus proche d'une base de données relationnelle.
Site officiel : http://www.mongodb.org/
github:https://github.com/mongodb/
Documentation API : https://www.mongodb.com/docs/
Pilote nodejs : https://github.com/mongodb/node-mongodb-native
Documentation : https://www.mongodb.com/zh-cn/docs/manual/
1.1 Installation de MongoDB
Lien de téléchargement : https://www.mongodb.com/try/download/community
Après téléchargement réussi, cliquez sur le fichier msi pour installer directement. Ici, nous prenons comme exemple le système d'exploitation Windows 7 64 bits.
1.1.1 Configuration de l'environnement d'exécution
Les nouvelles versions de MongoDB ne nécessitent pas de configuration complexe, ni d'installation séparée du client. Après installation, vous trouverez un client sur le bureau :
Cliquez sur connecter pour vous connecter avec succès.
1) Création d'un dossier pour les données
Créez un nouveau dossier dans n'importe quel répertoire sans caractères chinois, par exemple c:\donnees, dans ce dossier seront stockés les fichiers de base de données et les fichiers journaux de mongodb, comme :
c:\donnees\db pour stocker les fichiers de données mongodb
c:\donnees\journal pour stocker les fichiers journaux mongodb
2) Création du fichier de configuration
Ouvrez le répertoire d'installation de MongoDB comme "C:\Program Files\MongoDB\Serveur\3.4\bin", et créez un nouveau fichier mongo.config dans ce répertoire, le contenu du fichier est le suivant :
##Répertoire base de données##
cheminDb=C:\donnees\db
##Fichier journal sortie##
cheminJournal=C:\donnees\journal\db.log
3) Installation du service Windows
Ajouter le service lors de l'installation :
Utiliser cmd pour entrer dans la ligne de commande
Utiliser cd pour basculer vers le répertoire d'installation, par exemple : cd C:\Program Files\MongoDB\Serveur\3.4\bin
Installer le service MongoDB et spécifier le fichier de configuration, comme :
mongod --config "C:\Program Files\MongoDB\Serveur\3.4\bin\mongo.config" --install
4) Gestion des erreurs
Si pendant l'exécution vous voyez apparaître l'erreur "Impossible de localiser le point d'entrée ucrtbase.terminate dans la bibliothèque dynamique api-ms-win-crt-runtime-|1-1-0.dll", veuillez télécharger et installer "vc_redist.x64". Si l'installation de vc redis.x64 échoue, veuillez d'abord télécharger le correctif (KB2999226) puis installer.
5)Ajout variable environnementDans Ordinateur -> clic droit -> Avancé -> dans les variables d'environnement PATH ajoutez le chemin "C:\Program Files\MongoDB\Serveur\3.4\bin".
6) Démarrage du serviceExécutez la commande suivante dans la fenêtre cmd pour démarrer le service, vous pouvez également l'activer manuellement dans "Panneau de configuration\Tous les éléments du panneau de configuration\Outils d'administration\Services". Notez que par défaut, le service démarre automatiquement au démarrage, vous pouvez le configurer en démarrage manuel.
net start mongodb
Arrêt du service
net stop mongodb
Exécutez la commande suivante dans cmd
L'installation est ainsi réussie !
1.1.2 Exécution de MongoDB
1) Exécution directe
Si après installation vous ne souhaitez rien configurer, vous pouvez exécuter directement, où mongod.exe est le service, il faut d'abord le lancer, comme :
Lancer le fichier client mongo.exe, comme :
2) Exécution après démarrage du service
Utilisez net start mongodb ou démarrez manuellement le serveur pour exécuter le fichier client mongo.exe.
3) Outils de visualisation
Une fois le service démarré avec succès, si vous trouvez l'opération en ligne de commande peu pratique, vous pouvez utiliser des outils graphiques comme robomongo.
Site officiel : https://robomongo.org/
La deuxième option est une version portable, après décompression, trouvez le fichier exe dans le dossier et exécutez-le directement.
1.2 Opérations sur la base de données
1.2.1 Création et consultation de la base de données
Voici un exemple où nous créons la base de données gomall
Démarrer shell :
use nom_base_de_données, si la base de données n'existe pas elle est créée, utilisez show dbs pour voir toutes les bases de données
> use gomall switched to db gomall > db gomall
>db.gomall.insertOne({nom:"gomall"});
Si vous utilisez un outil GUI, vous pouvez créer une base de données en faisant un clic droit sur le nom de connexion et sélectionnez create database :
Après création réussie, cela ressemble à ceci :
Collections représente les collections, similaires aux tables dans les bases de données relationnelles.
Functions représente les fonctions, similaires aux procédures stockées et fonctions dans les bases de données relationnelles.
Users représente les utilisateurs.
document représente les enregistrements, similaires aux enregistrements ou lignes dans les bases de données relationnelles.
Si vous voulez voir toutes les bases de données, vous pouvez utiliser la commande show dbs : > show dbs
Dans MongoDB, la base de données par défaut est test, si vous ne créez pas de nouvelle base de données, les collections seront stockées dans la base de données test.
Création d'une collection
Utilisation de la ligne de commande pour créer :
1.2.2 Suppression de la base de données
> use gomall switched to db gomall > db.dropDatabase() { "dropped" : "gomall", "ok" : 1 }
1.2.3 Insertion de données
a) db.collection.insertOne(données)
Ici, les données peuvent être au format JSON
Ouvrez d'abord l'interface de script shell, opération comme suit :
db.films.insertOne(
{
titre: "Le Favori",
genres: [ "Drame", "Histoire" ],
duree: 121,
note: "R",
annee: 2018,
realisateurs: [ "Yorgos Lanthimos" ],
distribution: [ "Olivia Colman", "Emma Stone", "Rachel Weisz" ],
type: "film"
}
)
db.produits.insertOne({nom:"iphone",prix:1988});
Comme on peut le voir dans l'opération ci-dessus, aucune collection "produits" n'a été créée, mais en fait l'opération d'insertion la crée automatiquement _id est généré automatiquement par mongodb, chaque ligne de données contient cette valeur par défaut en tant qu'ObjectId, vous pouvez insérer cette clé lors de l'insertion des données (prend en charge tous les types de données pris en charge par mongodb)
Consulter les données : db.produits.find({})
b) db.nom_table.insertMany(données);
use exemple_mflix
db.films.insertMany([
{
titre: "Jurassic World: Le Royaume tombé",
genres: [ "Action", "Science-fiction" ],
duree: 130,
note: "PG-13",
annee: 2018,
realisateurs: [ "J. A. Bayona" ],
distribution: [ "Chris Pratt", "Bryce Dallas Howard", "Rafe Spall" ],
type: "film"
},
{
titre: "Tag",
genres: [ "Comédie", "Action" ],
duree: 105,
note: "R",
annee: 2018,
realisateurs: [ "Jeff Tomsic" ],
distribution: [ "Annabelle Wallis", "Jeremy Renner", "Jon Hamm" ],
type: "film"
}
])
_id peut être inséré manuellement, les champs ne doivent pas nécessairement être identiques dans une même table, bien que les méthodes insert et save puissent toutes deux insérer des données, lorsque la valeur par défaut "_id" existe déjà, l'appel de la méthode insert produira une erreur ; tandis que la méthode save ne le fera pas, elle mettra à jour les informations de la ligne de données avec le même _id.
1.2.4 Requête de données
a) Requête de toutes les données dans la collection : db.collection.find();
db.etudiants.find({nom:"tom"}); Recherche les données (document) dont la propriété nom est tom
Recherche de toutes les données sans condition comme :
db.etudiants.find()
b) Requête conditionnelle (prend en charge plusieurs conditions) : db.collection.find(condition);
db.etudiants.find({nom:"tom",age:19});
Les conditions dans l'objet doivent être remplies simultanément
c) Requête du premier élément (prend en charge les conditions) : db.collection.findOne(condition);
d) Limiter le nombre : db.collection.find().limit(nombre);
e) Sauter un nombre spécifié : db.nom_table.find().skip(nombre);
f) Requête comparative Supérieur à : ﹩gt Inférieur à : ﹩lt Supérieur ou égal à : ﹩gte Inférieur ou égal à : ﹩lte Différent de : ﹩ne
db.utilisateurs.find({age:{'﹩gt':9}});
Rechercher ceux dont l'âge est supérieur à 9 et inférieur à 11 ans
db.utilisateurs.find({age:{'﹩gt':9,'﹩lt':11}});
Requête des étudiants âgés de plus de 17 ans :
g) Compter les résultats : db.nom_table.find().count();
h) Tri : db.nom_table.find().sort({"nom_champ":1});
1 : ordre croissant, -1 : ordre décroissant
i) Retour de champs spécifiés : db.nom_table.find({},{"nom_champ":0}); Paramètre 1 : retourner 0 : ne pas retourner
Plus de détails : https://www.mongodb.com/docs/mongodb-shell/crud/read/#std-label-mongosh-read
1.2.5 Modification
Précédemment, save modifie les données quand le champ _id existe déjà, la syntaxe de modification selon condition spécifiée est la suivante :
db.collection.update({"nom_champ_condition":"valeur_champ"},{﹩set:{"nom_champ_modification":"valeur_champ_modifie"}});
db.utilisateurs.updateOne({age:{'﹩eq':9}},{﹩set:{age:100}});
Modification de plusieurs lignes :
db.utilisateurs.updateMany({age:{"﹩gte":10}},{﹩set:{age:30}});
Plus de détails
1.2.6 Suppression
db.collection.deleteOne(condition);
db.utilisateurs.deleteOne({age:{'﹩gte':10}}); Supprime les données des personnes âgées de >=10 ans
Suppression de plusieurs lignes
- Accès à MongoDB avec NodeJS =================
MongoDB fournit des pilotes d'accès à la base de données pour de nombreuses plateformes, telles que C#, Java, Node.js, etc. Ici, nous prenons Node.js comme exemple.
2.1 Installation du pilote d'accès MongoDB
Utilisation du gestionnaire de paquets, exécutez la commande suivante en ligne de commande :
Installation globale du pilote
npm install mongodb -g
Inclusion de mongodb dans le projet actuel
npm install mongodb --save
L'ajout du pilote est ainsi réussi.
Connexion à la base de données
const { ClientMongo } = require("mongodb"); //importer l'objet dépendance client mongo
let url="mongodb://127.0.0.1:27017"; //chaîne de connexion à la base de données
let client=new ClientMongo(url); //instancier un client mongo
async function executer(){
try{
await client.connecter(); //connexion
await client.db("nfit").commande({ping:1}); //envoyer une commande à la base de données nfit
console.log("Connexion à la base de données réussie !");
}
finally{
await client.fermer();
}
}
executer().catch(console.log);
Résultat d'exécution :
Notez que le mot-clé de connexion ne doit pas utiliser localhost
2.2 Ajout de données
Créez un nouveau fichier db.js dans le répertoire racine du projet, utilisez Node.js pour manipuler MongoDB.
Exemple de code :
const { ClientMongo } = require("mongodb"); //dépendance ClientMongo
let client=new ClientMongo("mongodb://127.0.0.1:27017"); //instancier un client
async function executer(){
try{
let db=await client.db("nfit"); //obtenir la base de données
let etudiants=await db.collection("etudiants"); //obtenir la collection, la table
let doc={id:202201,nom:"tom",age:19}; //objet des données à ajouter
let resultat=await etudiants.insertOne(doc); //exécuter l'ajout de données dans la base et attendre le résultat
console.log(resultat);
}
finally{
await client.fermer(); //fermer la base de données
}
}
executer().catch(console.log);
Résultat d'exécution :
Consultation de la base de données :
Ajout de plusieurs données
const { ClientMongo } = require("mongodb"); //dépendance ClientMongo
let client=new ClientMongo("mongodb://127.0.0.1:27017"); //instancier un client
async function executer(){
try{
let db=await client.db("nfit"); //obtenir la base de données
let etudiants=await db.collection("etudiants"); //obtenir la collection, la table
let docs=[{id:202202,nom:"rose",age:17},{id:202203,nom:"mark",age:18}]; //objet des données à ajouter
let resultat=await etudiants.insertMany(docs); //exécuter l'ajout de données dans la base et attendre le résultat
console.log(resultat);
}
finally{
await client.fermer(); //fermer la base de données
}
}
executer().catch(console.log);
Résultat d'exécution :
Plus de détails
2.3 Modification des données
Exemple de code :
const { ClientMongo } = require("mongodb");
let client=new ClientMongo("mongodb://127.0.0.1:27017");
async function executer(){
try{
let db=await client.db("nfit"); //obtenir la base de données
let etudiants=await db.collection("etudiants"); //obtenir la collection
let filtre={id:202201}; //condition de filtrage des données à mettre à jour
let resultat=await etudiants.updateOne(filtre,{$set:{nom:"Tom"}}); //exécuter la mise à jour d'une seule donnée
console.log(resultat);
}
finally{
await client.fermer(); //fermer
}
}
executer().catch(console.log);
Résultat d'exécution :
Plus de détails
2.4 Requête de données
2.4.1 Requête d'un seul enregistrement
Exemple de code :
const { ClientMongo } = require("mongodb");
let client=new ClientMongo("mongodb://127.0.0.1:27017");
async function executer(){
try{
let db=await client.db("nfit"); //obtenir la base de données
let etudiants=await db.collection("etudiants"); //obtenir la collection
let filtre={id:202201}; //condition de filtrage
let objet=await etudiants.findOne(filtre); //rechercher une seule donnée selon la condition de filtrage
console.log(objet);
}
finally{
await client.fermer(); //fermer
}
}
executer().catch(console.log);
Résultat d'exécution :
2.4.2 Requête de plusieurs enregistrements
Sortie directe
const { ClientMongo } = require("mongodb");
let client=new ClientMongo("mongodb://127.0.0.1:27017");
async function executer(){
try{
let db=await client.db("nfit"); //obtenir la base de données
let etudiants=await db.collection("etudiants"); //obtenir la collection
let requete={id:{$gte:202201}}; //condition de recherche : id supérieur ou égal à 202201
let curseur=await etudiants.find(requete); //exécuter la recherche et retourner l'objet curseur
let resultat=[]; //tableau d'étudiants, pour encapsulation du retour
await curseur.forEach(data=>resultat.push(data)); //parcourir le curseur, extraire les données
console.log(resultat);
}
finally{
await client.fermer(); //fermer
}
}
executer().catch(console.log);
Résultat de retour
const { ClientMongo } = require("mongodb");
let client=new ClientMongo("mongodb://127.0.0.1:27017");
async function executer(){
try{
let db=await client.db("nfit"); //obtenir la base de données
let etudiants=await db.collection("etudiants"); //obtenir la collection
let requete={id:{$gte:202201}}; //condition de recherche : id supérieur ou égal à 202201
let curseur=await etudiants.find(requete); //exécuter la recherche et retourner l'objet curseur
let resultat=[]; //tableau d'étudiants, pour encapsulation du retour
await curseur.forEach(data=>resultat.push(data)); //parcourir le curseur, extraire les données
return resultat;
}
finally{
await client.fermer(); //fermer
}
}
executer().then(console.log).catch(console.log);
Plus de détails
2.5 Suppression de données
Exemple de code :
const { ClientMongo } = require("mongodb");
let client=new ClientMongo("mongodb://127.0.0.1:27017");
async function executer(){
try{
let db=await client.db("nfit"); //obtenir la base de données
let etudiants=await db.collection("etudiants"); //obtenir la collection
let filtre={id:202201}; //condition de filtrage des données à supprimer
let resultat= await etudiants.deleteOne(filtre); //exécuter la suppression
console.log(resultat);
}
finally{
await client.fermer(); //fermer
}
}
executer().catch(console.log);
Résultat d'exécution :
- Accès MySQL avec Nodejs ===============
3.1 Importation du module mysql
- Ouvrir le répertoire racine, ouvrir le terminal, initialiser avec npm init -y ;
- Importer le module mysql : npm i mysql ;
3.2 Accès à la base de données
Exemple avec la base de données student dans la base gomall
3.2.1 Connexion et requête
const mysql=require("mysql"); //dépendance du module mysql
//création de l'objet pool de connexion
let pool=mysql.createPool({
hote:"localhost", //hôte
utilisateur:"root", //nom d'utilisateur
motdepasse:"123456", //mot de passe
base:"gomall" //base de données, le port peut être omis
});
pool.getConnection((connErr,conn)=>{ //obtenir l'objet de connexion
pool.query("select id,nom,sexe from etudiant",(err,resultats)=>{//exécuter la requête
if(err) throw err; //s'il y a une erreur, lever une exception
console.log(JSON.parse(JSON.stringify(resultats))); //convertir et afficher les résultats de la requête
conn.release(); //libérer la connexion
});
});
3.2.2 Requête avec paramètres
const mysql=require("mysql"); //dépendance du module mysql
//création de l'objet pool de connexion
let pool=mysql.createPool({
hote:"localhost", //hôte
utilisateur:"root", //nom d'utilisateur
motdepasse:"123456", //mot de passe
base:"gomall" //base de données, le port peut être omis
});
pool.getConnection((connErr,conn)=>{ //obtenir l'objet de connexion
pool.query("select id,nom,sexe from etudiant where sexe=?",['garcon'],(err,resultats)=>{//exécuter la requête
if(err) throw err; //s'il y a une erreur, lever une exception
console.log(JSON.parse(JSON.stringify(resultats))); //convertir et afficher les résultats de la requête
conn.release(); //libérer la connexion
});
});
3.2.3 Ajout de données
const mysql=require("mysql"); //dépendance du module mysql
//création de l'objet pool de connexion
let pool=mysql.createPool({
hote:"localhost", //hôte
utilisateur:"root", //nom d'utilisateur
motdepasse:"123456", //mot de passe
base:"gomall" //base de données, le port peut être omis
});
let sql="insert into etudiant(nom,sexe) values(?,?)";
pool.getConnection((connErr,conn)=>{ //obtenir l'objet de connexion
pool.query(sql,['tom','garcon'],(err,resultats)=>{//exécuter l'ajout, spécifier les paramètres
if(err) throw err; //s'il y a une erreur, lever une exception
console.log(resultats); //afficher les résultats
conn.release(); //libérer la connexion
});
});
Résultat
3.2.4 Ajout simplifié
const mysql=require("mysql"); //dépendance du module mysql
//création de l'objet pool de connexion
let pool=mysql.createPool({
hote:"localhost", //hôte
utilisateur:"root", //nom d'utilisateur
motdepasse:"123456", //mot de passe
base:"gomall" //base de données, le port peut être omis
});
let sql="insert into etudiant set ?";
let etudiant={nom:"rose",sexe:"fille"};
pool.getConnection((connErr,conn)=>{ //obtenir l'objet de connexion
pool.query(sql,etudiant,(err,resultats)=>{//exécuter l'ajout, spécifier l'objet paramètre
if(err) throw err; //s'il y a une erreur, lever une exception
console.log(resultats); //afficher les résultats
conn.release(); //libérer la connexion
//process.exit(1); //fermer l'application
});
});
3.2.5 Mise à jour des données
const mysql=require("mysql"); //dépendance du module mysql
//création de l'objet pool de connexion
let pool=mysql.createPool({
hote:"localhost", //hôte
utilisateur:"root", //nom d'utilisateur
motdepasse:"123456", //mot de passe
base:"gomall" //base de données, le port peut être omis
});
let sql="update etudiant set nom=?,sexe=? where id=?";
pool.getConnection((connErr,conn)=>{ //obtenir l'objet de connexion
pool.query(sql,['mark','garcon',34],(err,resultats)=>{//exécuter la mise à jour, spécifier les paramètres
if(err) throw err; //s'il y a une erreur, lever une exception
console.log(resultats); //afficher les résultats
conn.release(); //libérer la connexion
});
});
3.2.6 Mise à jour simplifiée des données
const mysql=require("mysql"); //dépendance du module mysql
//création de l'objet pool de connexion
let pool=mysql.createPool({
hote:"localhost", //hôte
utilisateur:"root", //nom d'utilisateur
motdepasse:"123456", //mot de passe
base:"gomall" //base de données, le port peut être omis
});
let sql="update etudiant set ? where id=?";
let etudiant={nom:"jone",sexe:'garcon'};
pool.getConnection((connErr,conn)=>{ //obtenir l'objet de connexion
pool.query(sql,[etudiant,33],(err,resultats)=>{//exécuter la mise à jour, spécifier les paramètres
if(err) throw err; //s'il y a une erreur, lever une exception
console.log(resultats); //afficher les résultats
conn.release(); //libérer la connexion
});
});
3.2.7 Suppression de données
const mysql=require("mysql"); //dépendance du module mysql
//création de l'objet pool de connexion
let pool=mysql.createPool({
hote:"localhost", //hôte
utilisateur:"root", //nom d'utilisateur
motdepasse:"123456", //mot de passe
base:"gomall" //base de données, le port peut être omis
});
let sql="delete from etudiant where id=?";
pool.getConnection((connErr,conn)=>{ //obtenir l'objet de connexion
pool.query(sql,[33],(err,resultats)=>{//exécuter la requête
if(err) throw err; //s'il y a une erreur, lever une exception
if(resultats.lignesAffectees===1){ //si le nombre de lignes affectées est 1
console.log("Suppression réussie");
}
else{
console.log("Suppression échouée");
}
conn.release(); //libérer la connexion
});
});
Script d'accès à la base de données :
const mysql=require("mysql");
const pool=mysql.createPool({
hote:"localhost",
utilisateur:"root",
motdepasse:"123456",
base:"gomall",
port:3306
});
//requête
pool.query("select * from etudiant",(err,resultats)=>{
resultats=JSON.parse(JSON.stringify(resultats));
resultats.forEach((etu,index)=>{
console.log(etu.id,etu.nom,etu.sexe);
});
});
//ajout
let sql="insert into etudiant(nom,sexe) values(?,?)";
pool.query(sql,['rose','fille'],(err,resultats)=>{
if(err) throw err;
if(resultats.lignesAffectees===1){
console.log("Ajout réussi !");
}
});
//ajout simplifié
sql="insert into etudiant set ?";
let etudiant={nom:"mark",sexe:"garcon"};
pool.query(sql,etudiant,(err,resultats)=>{
if(err) throw err;
if(resultats.lignesAffectees===1){
console.log("Ajout simplifié réussi !");
}
});
//modification
sql="update etudiant set nom=? where id=?";
pool.query(sql,['lili',26],(err,resultats)=>{
if(err) throw err;
if(resultats.lignesAffectees===1){
console.log("Modification réussie !");
}
});
//modification simplifiée
sql="update etudiant set ? where id=?";
etudiant={nom:"mark1",sexe:"fille"};
pool.query(sql,[etudiant,26],(err,resultats)=>{
if(err) throw err;
if(resultats.lignesAffectees===1){
console.log("Modification simplifiée réussie !");
}
});
//suppression
sql="delete from etudiant where id=?";
pool.query(sql,[25],(err,resultats)=>{
if(err) throw err;
if(resultats.lignesAffectees===1){
console.log("Suppression réussie !");
}
});
Libération de la connexion :
//requête
pool.getConnection((err,conn)=>{
pool.query("select * from etudiant",(err,resultats)=>{
resultats=JSON.parse(JSON.stringify(resultats));
resultats.forEach((etu,index)=>{
console.log(etu.id,etu.nom,etu.sexe);
});
conn.release();
process.exit(1);
});
});
Script de référence
// 1. importer le module mysql
const mysql = require('mysql')
// 2. établir la connexion avec la base de données MySQL
const db = mysql.createPool({
hote: '127.0.0.1', //adresse IP de la base de données
utilisateur: 'root', //compte de connexion à la base de données
motdepasse: 'hoshi1234', //mot de passe de connexion à la base de données
datebase: 'ma_bd_01' //spécifier la base de données à manipuler
})
// 3. tester si le module mysql fonctionne normalement
db.query('select 1',(err, resultats) => {
// erreur pendant le fonctionnement de mysql
if(err) return console.log(err.message);
// peut exécuter normalement la requête SQL
console.log(resultats);
// retourne [ RowDataPacket { '1': 1 } ]
})
// 4. requête de toutes les données dans la table users
const chaineSql = 'select * from ma_bd_01.users'
db.query(chaineSql ,(err, resultats) => {
// erreur pendant le fonctionnement de mysql
if(err) return console.log(err.message);
// peut exécuter normalement la requête SQL
console.log(resultats);
// retourne les champs de la table users
})
// 5. insertion de données dans la table users
// données à insérer dans la table
const utilisateur = { nomutilisateur: 'benben', motdepasse:'886886' }
// requête SQL à exécuter, le point d'interrogation anglais ? représente un espace réservé (syntaxe SQL)
const chaineSql2 = 'insert into users (nomutilisateur, motdepasse) VALUES (?,?)'
// utilisation d'un tableau pour attribuer des valeurs spécifiques à chaque espace réservé ?
db.query(chaineSql2, [utilisateur.nomutilisateur , utilisateur.motdepasse],(err, resultats) => {
// erreur pendant le fonctionnement de mysql
if(err) return console.log(err.message);
// si l'instruction insert into est exécutée, alors resultats est un objet
// peut vérifier la réussite via resultats.lignesAffectees
if(resultats.lignesAffectees === 1) {
console.log('Insertion des données réussie');
// ouvrir la table users dans MySQL permet aussi de voir les nouvelles données
// la table actuelle ne contient que 4 lignes, pourquoi cet ID est-il 5 ?
// car il y avait auparavant des données avec ID 4, mais elles ont été supprimées, les ID sont uniques, une fois supprimés ils ne peuvent pas être réutilisés par d'autres données
}
})
// méthode simplifiée d'insertion de données
const utilisateur = { nomutilisateur: 'niuniu', motdepasse:'000000' }
// définition de la requête SQL à exécuter
const chaineSql = 'insert into ma_bd_01.users set ?'
// exécution de la requête SQL
db.query(chaineSql, utilisateur,(err, resultats) => {
if(err) return console.log(err.message);
if(resultats.lignesAffectees === 1) {
console.log('Insertion des données réussie');
}
})
// comment mettre à jour les informations utilisateur (la requête UPDATE sert à modifier les enregistrements existants dans la table)
// données à insérer dans la table
const utilisateur = { id: 6, nomutilisateur: 'Benben', motdepasse:'000111' }
// définition de la requête SQL
const chaineSql = 'update ma_bd_01.users set nomutilisateur=?, motdepasse=? where id=?'
// exécution de la requête SQL
db.query(chaineSql,[utilisateur.nomutilisateur, utilisateur.motdepasse, utilisateur.id], (err, resultats) => {
if(err) return console.log(err.message);
if(resultats.lignesAffectees === 1) {
console.log('Insertion des données réussie');
}
})
// méthode simplifiée de mise à jour des informations utilisateur (utilisable lorsque chaque propriété de l'objet de données correspond à un champ)
const utilisateur = { id: 6, nomutilisateur: 'Kuakuaniu', motdepasse:'000111' }
// définition de la requête SQL
const chaineSql = 'update ma_bd_01.users set ? where id=?'
// exécution de la requête SQL
db.query(chaineSql,[utilisateur, utilisateur.id], (err, resultats) => {
if(err) return console.log(err.message);
if(resultats.lignesAffectees === 1) {
console.log('Insertion des données réussie');
}
})
// suppression de données
// définition de la requête SQL
const chaineSql = 'delete from ma_bd_01.users where id=?'
// exécution de la requête SQL
// si la requête SQL contient plusieurs espaces réservés, un tableau doit être utilisé pour attribuer des valeurs à chaque espace réservé
// s'il n'y a qu'un seul espace réservé, le tableau peut être omis
db.query(chaineSql,5,(err,resultats) => {
if(err) return console.log(err.message);
if(resultats.lignesAffectees === 1) {
console.log('Suppression des données réussie');
}
})
// suppression marquée
// l'utilisation de la requête delete supprimera réellement les données, ce qui est très dangereux, généralement il est recommandé d'utiliser la suppression marquée, similaire à la modification du statut d'un champ, par exemple le mettre à 1 pour indiquer suppression ;
// définition de la requête SQL
const chaineSql = 'update ma_bd_01.users set statut=? where id=?'
// exécution de la requête SQL
db.query(chaineSql,[1, 3],(err, resultats) => {
if(err) return console.log(err.message);
if(resultats.lignesAffectees === 1) {
console.log('Suppression marquée réussie');
}
})
3.3 Encapsulation du code
À partir des exemples ci-dessus, on peut constater que le code d'accès à la base de données contient beaucoup de répétitions, pour faciliter la maintenance et l'extension, on peut encapsuler le code d'accès à la base de données.
mysqlutil.js
const mysql=require("mysql"); //dépendance du module mysql
//création de l'objet pool de connexion
let pool=mysql.createPool({
hote:"localhost", //hôte
utilisateur:"root", //nom d'utilisateur
motdepasse:"123456", //mot de passe
base:"gomall" //base de données, le port peut être omis
});
function requete(sql,param){
return new Promise((resolve,reject)=>{
pool.getConnection((connErr,conn)=>{ //obtenir l'objet de connexion
pool.query(sql,param||[],(err,resultats)=>{//exécuter sql
try{
if(err) reject(err);
resolve(JSON.parse(JSON.stringify(resultats)));
}
finally{
conn.release(); //libérer la connexion
}
});
});
});
}
module.exports={requete};
Code de test :
const mysqlutil=require("./mysqlutil"); //importer le module outil mysql
//requête de tous
//mysqlutil.requete("select * from etudiant").then(console.log).catch(console.log);
//requête avec paramètres
//mysqlutil.requete("select * from etudiant where id=?",[1]).then(console.log).catch(console.log);
//exécuter la mise à jour
let sql="update etudiant set ? where id=?";
let etudiant={nom:"Zhang Er",sexe:"fille"};
//mysqlutil.requete(sql,[etudiant,1]).then(console.log).catch(console.log);
async function toutTrouver(){
try{
let resultat= await mysqlutil.requete("select * from etudiant");
return resultat;
}
catch(err){
throw err;
}
}
toutTrouver().then(console.log);
- Vidéo ====
[Node.js Learning Summary - Zhang Guo] https://www.bilibili.com/video/BV1WW411B78S?share_source=copy_web&vd_source=475a31f3c5d6353a782007cd4c638a8a
- Devoirs ====
5.1 Réaliser une fonction de gestion de bibliothèque, les livres comprennent (numéro, nom, auteur, image, prix), réaliser :
a) Utiliser Node.js+Express+Axios+RESTful+MongoDB+Vue
c) Utiliser Node.js+Express+Axios+Rest+MySQL+Vue
La page n'a pas besoin d'être exactement identique, on peut utiliser un framework UI.