Discussion :

[Slayes]

Bonjour à tous,

Je suis à la recherche d'une méthodologie pour faire des enregistrements dans la base de donnée (Mysql) qui donne le code le plus clair.
J'ai mis un exemple ci-dessous lié à la création d'un utilisateur, générant des enregistrements dans 3 tables.

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
CREATE TABLE `user` (
  `id` int NOT NULL,
  `login` varchar(20) NOT NULL,
  `password` varchar(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
ALTER TABLE `user`
  ADD PRIMARY KEY (`id`),
  ADD UNIQUE KEY `user` (`login`);
 
CREATE TABLE `address` (
  `id` int NOT NULL,
  `route` varchar(20) NOT NULL,
  `postal_code` varchar(20) NOT NULL,
  `country` varchar(20) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
ALTER TABLE `address`
  ADD PRIMARY KEY (`id`)
 
CREATE TABLE `cat` (
  `id` int NOT NULL,
  `idUser` int NOT NULL,
  `idAddress` int NOT NULL,
  `name` varchar(20) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
ALTER TABLE `cat`
  ADD PRIMARY KEY (`id`)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
var dataNew = {id: null, cat: 'christian', user: {login: 'loginTest', password: 'passTest'}, address: {route: '123 rue de la lune', postal_code: 59000, country: 'lille'}} // Nouvel enregistrement
var dataUpdate = {id: 1, cat: 'christian', user: {login: 'loginTest', password: 'ModifduPass'}, address: {route: '69 rue de la lune', postal_code: 59000, country: 'lille'}} // Enregistrement à modifier

Jusqu'à présent j'imbriquais mes requêtes les une dans les autres (voir ci-dessous). Mais ça devient trés vite lourd, puisqu'il faut vérifier si insert ou update ..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   connection.query(mysql.format(req_user_sel1,[_this._login!=''?_this._login:new Date().getTime(), req.session.user.idCat, req.session.user.idCat]), function(err, rows) {
      if (err) {
        .....
      }  else if (rows.length==0) {
        connection.query(mysql.format(req_client_sel6,[_this._code, req.session.user.idCat]), function(err, rows) {
          if (err) {
           ....
          } else {
            if (rows.length > 0) {
              _this.message.error.push("Le code '" + _this._code + "' est déjà utilisé.");
              return _this.stop();
            }
            connection.query(mysql.format(req_client_ins2,[req.session.user.idCat, _this._code,  _this._comment, "{}", _this._activated]), function(err, rows) {
              if (err||rows.affectedRows==0) {
 				....
              } else {
                _this._id = rows.insertId;
                connection.query(mysql.format(req_user_ins2,[_this._id, _this._login, _this._password, _this._activated]), function(err, rows) {
                  if (err||rows.affectedRows==0) {
                    ....

C'est pour cela que je suis à la recherche de conseil pour une organisation/méthode pour enregistrer des données dans plusieurs tables au cours d'un même process.

Merci par avance à celui qui pourra m'aiguiller

[djedjethai]

Si c'est une methode pour eclaircir les Call-back imbriquees les unes dans les autres (souvent appele ''call-back hell'') que tu recherches: il faut promisifier les CB puis puis se servir de async/await pour les presenter de maniere ''serial'' (comme un code non-async). Ainsi le code devient plus lisible.

le module 'util' present dans la Standart library (node core) de Nodejs permet de promisifier facilement les Call-B.

Avec les promises (et donc async/await) les exceptions deviennent des Rejections, elles sont automatiquement 'throw()' donc necessite d'etre catch(). Ensuite a toi de les 'handle' suivant tes besoins.

je reprends ton ex (il se peut qu il y ai des err de parentheses... je fais ca vite fais...):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
const { promisify } = require('util')
 
function returnCB(e, d) {
        if(e) return e
        else return d
}
 
async function runQueries(){
        try{
                let rows = await promisify((returnCB) => connection.query(mysql.format(req_user_sel1,[_this._login!=''?_this._login:new Date().getTime(), req.session.user.idCat, req.session.user.idCat]), returnCB)()
                if (rows.length==0) {
                rows = await promisify((returnCB) => connection.query(mysql.format(req_client_sel6,[_this._code, req.session.user.idCat]), returnCB)()
                        if (rows.length > 0) {
                                _this.message.error.push("Le code '" + _this._code + "' est déjà utilisé.");
                                return _this.stop();
                        }   
                        rows = await promisify((returnCB) => connection.query(mysql.format(req_client_ins2,[req.session.user.idCat, _this._code,  _this._comment, "{}", _this._activated]), returnCB)()
                        if (rows.affectedRows==0) {
                                // ici de la meme maniere l'erreur sera catch()
                                throw new Error()
                        }   
                        else {
                                _this._id = rows.insertId 
                                rows = await promisify((returnCB) => connection.query(mysql.format(req_user_ins2,[_this._id, _this._login, _this._password, _this._activated]), returnCB)()
                                        if (rows.affectedRows==0) {
                                        ..........
                                        }   
                        }
                }   
        } catch(e) {
                console.log('handle the Errors')
        }   
}
 
 
runQueries()

Voici un autre exemple pour la comprehenssion. La function 'readFile()' est async et lit le file 'myFile.js' (ici __filename pour l'ex), elle retourne une CB(err, data), pareil que query()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
const { promisify } = require('util')
const { readFile } = require('fs')
 
function ret(e, d) {
        if(e) return e
        else return d
}
 
async function as(){
        try{
                // remplace __filename par un nom bidon 'inexistant.js' et tu atteris dans le catch(e)
                const rr = promisify((ret) => readFile(__filename, 'utf8', ret))
                const r = await rr()
 
                // lignes precedentes refactorisees
                // const r = await promisify((ret) => readFile(__filename, 'utf8', ret))()
 
                console.log(r)
                console.log('end')
 
        }  catch(e) {
                console.log('handled')
        }       
}
 
as()