IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre régulier
    Profil pro
    Inscrit en
    août 2004
    Messages
    185
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : août 2004
    Messages : 185
    Points : 79
    Points
    79
    Par défaut Conseil sur l'organisation/méthode d'enregistrement de donnée
    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

  2. #2
    Membre habitué
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2018
    Messages
    104
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Thaïlande

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2018
    Messages : 104
    Points : 133
    Points
    133
    Par défaut
    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()

Discussions similaires

  1. Conseil sur appel de méthode
    Par Melvine dans le forum Débuter avec Java
    Réponses: 4
    Dernier message: 17/12/2013, 21h26
  2. Conseils sur l'organisation de mon appli
    Par Turvy dans le forum Android
    Réponses: 5
    Dernier message: 02/12/2013, 12h33
  3. [MLD] Conseil sur l'organisation de tables
    Par Eruvatar dans le forum Schéma
    Réponses: 3
    Dernier message: 12/11/2009, 15h28
  4. Réponses: 6
    Dernier message: 13/12/2007, 13h30
  5. Conseil sur l'organisation du code
    Par Fly3R dans le forum Windows Forms
    Réponses: 7
    Dernier message: 07/11/2007, 16h39

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo