Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation.
Pour créer une application Web prête pour la production, vous devez vous assurer qu'elle est sûre et évolutive.
L'une des choses les plus cruciales à savoir sur les bases de données est le principe ACID qui représente l'atomicité, la cohérence, l'isolement et la durabilité. Les bases de données relationnelles telles que MySQL prennent en charge les transactions ACID de manière native. Mais MongoDB est une base de données NoSQL et ne prend pas en charge les transactions ACID par défaut.
En tant que programmeur, vous devez savoir comment introduire les propriétés ACID dans vos bases de données MongoDB.
Que sont les transactions de base de données ?
Une transaction de base de données est une séquence de requêtes ou d'opérations de base de données qui s'exécutent toutes ensemble comme une seule unité pour accomplir une tâche.
Les transactions de base de données adhèrent aux concepts des caractéristiques ACID. Cela permet de s'assurer qu'aucune modification ne se produit à moins que toutes les opérations ne réussissent. Il assure également la cohérence de la base de données.
Les propriétés ACID expliquées
Les quatre propriétés qui composent les principes ACID sont :
- Atomicité est la propriété qui conceptualise les transactions comme de petites unités d'un programme. Cela implique que toutes les requêtes s'exécutent avec succès ou échouent ensemble.
- Cohérence stipule que les enregistrements de la base de données doivent rester cohérents avant et après chaque transaction.
- Isolement garantit que, lorsque plusieurs transactions s'exécutent simultanément, l'une n'affecte pas l'autre.
- Durabilité se concentre sur les défaillances ou les défauts du système. Il garantit qu'une transaction validée n'est pas perdue en cas de défaillance du système. Cela peut impliquer des techniques nécessaires pour restaurer automatiquement les données à partir d'une sauvegarde une fois que le système redémarre.
Comment implémenter les transactions de base de données MongoDB dans Node.js à l'aide de Mongoose
MongoDB est devenu une technologie de base de données largement utilisée au fil des ans en raison de sa nature NoSQL et un modèle flexible basé sur des documents. Il vous offre également la possibilité de mieux organiser vos données et de manière plus flexible que dans les bases de données SQL ou relationnelles.
Pour implémenter des transactions de base de données dans MongoDB, vous pouvez envisager un exemple de scénario sur une application de liste d'emplois où un utilisateur peut publier, mettre à jour ou supprimer un emploi. Voici une conception de schéma de base de données simple pour cette application :
Pour suivre, cette section nécessite une connaissance de base de la programmation Node.js et de MongoDB.
Les transactions ne sont pas prises en charge sur les installations MongoDB autonomes. Vous devrez utiliser un Ensemble de réplicas MongoDB ou Cluster partitionné MongoDB pour que les transactions fonctionnent. Par conséquent, la manière la plus simple d'utiliser les transactions consiste à créer une instance MongoDB hébergée dans le cloud (Atlas MongoDB). Par défaut, chaque instance de base de données Atlas est un jeu de réplicas ou un cluster partitionné.
Après avoir configuré un projet Node.js et MongoDB fonctionnel, vous pouvez configurer une connexion à une base de données Mongo dans Node.js. Si vous ne l'avez pas encore fait, installez mongoose en exécutant npm installer la mangouste dans votre borne.
importer mangouste depuis 'mangouste'laissez MONGO_URL = process.env. MONGO_URL || 'votre-mongo-base-de-données-url';
laisser connexion;
constante connectDb = asynchrone () => {
essayer {
attendre mongoose.connect (MONGO_URL, {
useNewUrlParser: vrai,
useUnifiedTopology: vrai,
});
console.log("CONNECTÉ À LA BASE DE DONNÉES");
connexion = mangouste.connexion ;
} attraper (erre) {
console.error("ÉCHEC DE LA CONNEXION À LA BASE DE DONNÉES !");
console.erreur(se tromper.message);
processus.sortie(1); // ferme l'application si la connexion à la base de données échoue
}
};
Vous devez stocker la connexion dans une variable afin de pouvoir l'utiliser pour initier une transaction ultérieurement dans le programme.
Vous pouvez implémenter les collections d'utilisateurs et de travaux comme suit :
constante userSchema = nouveau mangouste. Schéma({
nom: Chaîne,
e-mail: Chaîne,
emplois: [mangouste. Schéma. Les types. ID d'objet]
});constante jobSchema = nouveau mangouste. Schéma({
titre: Chaîne,
emplacement: Chaîne,
salaire: Chaîne,
affiche: mangouste.Schéma.Les types.ObjectId
});
const userCollection = mongoose.model('utilisateur', userSchema);
const jobCollection = mongoose.model('emploi', jobSchema);
Vous pouvez écrire une fonction pour ajouter un utilisateur à la base de données comme ceci :
constante créerutilisateur = asynchrone (utilisateur) => {
constante nouvelutilisateur = attendre userCollection.create (utilisateur);
console.log("Utilisateur ajouté à la base de données");
console.log (nouvelutilisateur);
}
Le code ci-dessous illustre la fonction permettant de créer un travail et de l'ajouter à la liste des travaux de son affiche à l'aide d'une transaction de base de données.
constante créerJob = asynchrone (travail) => {
constante { userEmail, titre, emplacement, salaire } = travail ;// récupère l'utilisateur de la base de données
constante utilisateur = attendre userCollection.findOne({ e-mail: userEmail });// démarre la session de transaction
constante séance = attendre connexion.startSession();// exécute toutes les requêtes de base de données dans un bloc try-catch
essayer {
attendre session.startTransaction();// crée le travail
constante nouveau travail = attendre jobCollection.create(
[
{
titre,
emplacement,
salaire,
affiche: user._id,
},
],
{ session }
);
console.log("Créé nouveau travail réussi !");
console.log (nouveauTravail[0]);// ajoute un emploi à la liste des utilisateurs des emplois publiés
constante newJobId = nouveauJob[0]._identifiant;
constante ajouté à l'utilisateur = attendre userCollection.findByIdAndUpdate(
ID de l'utilisateur,
{ $addToSet: { emplois: newJobId } },
{ session }
);console.log("Le travail a été ajouté avec succès à la liste des travaux de l'utilisateur");
console.log (ajouté à l'utilisateur) ;attendre session.commitTransaction();
console.log("Transaction DB effectuée avec succès");
} attraper (e) {
console.erreur (e);
console.log("Impossible de terminer les opérations de base de données");
attendre session.abortTransaction();
} enfin {
attendre session.endSession();
console.log("Session de transaction terminée");
}
};
UN créer La requête qui s'exécute dans une transaction accepte et renvoie généralement un tableau. Vous pouvez le voir dans le code ci-dessus où il crée nouveau travail et stocke ses _identifiant propriété dans lenewJobId variable.
Voici une démonstration du fonctionnement des fonctions ci-dessus :
constante mockUser = {
nom: "Timmy Omolana",
email: "[email protected]",
};constante travail factice = {
titre: "Responsable des ventes",
lieu: "Lagos, Nigéria",
salaire: "$40,000",
userEmail: "[email protected]", // email de l'utilisateur créé
};constante startServer = asynchrone () => {
attendre connectDb();
attendre createUser (mockUser);
attendre createJob (mockJob);
};
startServer()
.alors()
.catch((err) => console.log (erreur) );
Si vous enregistrez ce code et l'exécutez en utilisant début npm ou la nœud commande, il devrait produire une sortie comme celle-ci :
Une autre façon d'implémenter des transactions ACID dans MongoDB à l'aide de Mongoose consiste à utiliser le avecTransaction() fonction. Cette approche offre peu de flexibilité car elle exécute toutes les requêtes à l'intérieur d'une fonction de rappel que vous transmettez comme argument à la fonction.
Vous pouvez refactoriser la transaction de base de données ci-dessus pour utiliser avecTransaction() comme ça:
constante créerJob = asynchrone (travail) => {
constante { userEmail, titre, emplacement, salaire } = travail ;// récupère l'utilisateur de la base de données
constante utilisateur = attendre userCollection.findOne({ e-mail: userEmail });// démarre la session de transaction
constante séance = attendre connexion.startSession();// exécute toutes les requêtes de base de données dans un bloc try-catch
essayer {
constante transactionRéussite = attendre session.withTransaction(asynchrone () => {
constante nouveau travail = attendre jobCollection.create(
[
{
titre,
emplacement,
salaire,
affiche: user._id,
},
],
{ session }
);console.log("Créé nouveau travail réussi !");
console.log (nouveauTravail[0]);// ajoute un emploi à la liste des utilisateurs des emplois publiés
constante newJobId = nouveauJob[0]._identifiant;
constante ajouté à l'utilisateur = attendre userCollection.findByIdAndUpdate(
ID de l'utilisateur,
{ $addToSet: { emplois: newJobId } },
{ session }
);console.log("Le travail a été ajouté avec succès à la liste des travaux de l'utilisateur");
console.log (ajouté à l'utilisateur) ;
});
si (réussite de la transaction) {
console.log("Transaction DB effectuée avec succès");
} autre {
console.log("Échec de la transaction");
}
} attraper (e) {
console.erreur (e);
console.log("Impossible de terminer les opérations de base de données");
} enfin {
attendre session.endSession();
console.log("Session de transaction terminée");
}
};
Cela produirait le même résultat que l'implémentation précédente. Vous êtes libre de choisir le style à utiliser lors de la mise en œuvre des transactions de base de données dans MongoDB.
Cette implémentation n'utilise pas le commitTransaction() et abandonnerTransaction() les fonctions. C'est parce que le avecTransaction() La fonction valide automatiquement les transactions réussies et annule celles qui ont échoué. La seule fonction que vous devez appeler dans tous les cas est la session.endSession() fonction.
Implémentation des transactions de base de données ACID dans MongoDB
Les transactions de base de données sont faciles à utiliser lorsqu'elles sont effectuées correctement. Vous devez maintenant comprendre comment fonctionnent les transactions de base de données dans MongoDB et comment vous pouvez les implémenter dans les applications Node.js.
Pour explorer davantage l'idée des transactions ACID et leur fonctionnement dans MongoDB, envisagez de créer un portefeuille fintech ou une application de blog.