nodejs, mysql, async itterative functions

Question

I'm having a bit of trouble with an itterative function in nodejs.

I'm stepping through an object and checking if that object has any sub-objects attached (think: a star has a planet has a moon has an orbital station has a ship).

I'm trying to assemble this all into a nice array of objects to push to the client.

Here's the function:

        var subNodeProc = function(nodeList,sqlP,itteration_count) {
            var async = require('async');

            --itteration_count;
            async.each(nodeList,function(dd,cb){

                    var simple = {
                        sql:sqlP,
                        values:[dd.node_id],
                        timeout:40000
                    };

                    dd.subnodes = false;
                    connection.query(simple, function(err,rslt){
                        if (err) {
                            cb(err);
                        } else {
                            if (rslt.length > 0) {

                                var r = nodeList.indexOf(dd);
                                if (itteration_count > 0) {
                                    rslt = subNodeProc(rslt,sqlP,itteration_count);
                                }
                                nodeList[r].subnodes = rslt;

                            }
                            cb();
                        }
                    });

            },function(err){

                if (err) {
                    return err;
                } else {
                    return nodeList;
                }

            });

        }

When I trigger the function it returns a nodelist of undefined. Can anyone give me a pointer in the right direction? I can't get it to work

Thanks!

Edit: here's a sample of the data I'm itterating over:

The SQL statement:

SELECT n.id as node_id, n.name, n.system_id, n.parent_id as parent_id FROM nodes as n WHERE n.parent_id = ?

Sample nodeList for input:

[ { node_id: 1,
    name: 'Planet A',
    system_id: 1,
    parent_id: null,
},
{ node_id: 2,
    name: 'Moon',
    system_id: 1,
    parent_id: 1,
},
{ node_id: 3,
    name: 'Debris',
    system_id: 1,
    parent_id: 2,
},
{ node_id: 4,
    name: 'Asteroid',
    system_id: 1,
    parent_id: 1,
} ]

Moon A has a parent_id of 1 and node_id of 2, moon A also has a ship (ship A, node_id:3, parent_id:2) orbiting it.

What I want :

[ { node_id: 1,
    name: 'Planet A',
    system_id: 1,
    parent_id: null,
    subnodes:[{
        node_id: 2,
        name: 'Moon A',
        system_id: 1,
        parent_id: 1,
        subnodes: [{
            node_id:3,
            name: 'Ship A',
            system_id:1,
            parent_id:2
        },
        {...}]
    },
    {...}]
},
{...}]

shennan · Accepted Answer · 2015-12-11 12:44:37Z

1

It's hard to tell whether there are any other major issues because I cannot see the data which you are feeding the method. However, there is one major problem with this: you're attempting to return data from a method that uses asynchronous method calls.

The asynchronous way is to return values via a callback. In your code, the very last function in your example (the callback) is called from a completely different scope (from within the async framework) so your nodeList or err is being lost in a scope you don't control.

You need to rethink your code so that the returned data is passed to a callback. You could leverage the async callback for this. Ad a callback argument to your subNodeProc method. Then you can call that callback, after async has finished, passing it the nodeList:

var subNodeProc = function (nodeList, sqlP, itteration_count, cb) {

    var async = require('async');

    --itteration_count;
    async.each(nodeList,function(dd, cb){

      var simple = {
          sql:sqlP,
          values:[dd.node_id],
          timeout:40000
      };

      dd.subnodes = false;
      connection.query(simple, function(err, rslt){
          if (err) {
              cb(err);
          } else {
              if (rslt.length > 0) {

                  var r = nodeList.indexOf(dd);
                  if (itteration_count > 0) {
                      rslt = subNodeProc(rslt,sqlP,itteration_count);
                  }
                  nodeList[r].subnodes = rslt;

              }
              cb();
          }
      });

    }, function (err) {

        if (err)
            throw err;
        else
            cb(nodeList);

    });
}

You would then use the method like this:

subNodeProc(nodeList, sqlP, itteration_count, function (processed) {

  console.log(processed);

  /* do whatever you want afterwards here */

});

answered Dec 11, 2015 at 12:44

shennan

11.8k5 gold badges52 silver badges94 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

sn0r Over a year ago

Awesome, thanks. I do see that in the itteration (rslt = subNodeProc(rslt,sqlP,itteration_count);) you don't pass a callback. Correct?

shennan Over a year ago

@sn0r Ah, I didn't spot that call. That does complicate things slightly, because you are calling the same method. Can you provide some sample data in your question so that I can better understand your use-case? I will come back to this in a few hours.

sn0r Over a year ago

Thanks for your troubles :) I've added some example data.

shennan Over a year ago

@sn0r apologies I didn't have time to look at this again today. It looks like you've got the gist of it though; as a rule of thumb, when a method becomes asynchronous, it must use a callback. So that is true of the line you pointed out earlier in your comment. Glad you managed to apply the logic successfully.

sn0r · Accepted Answer · 2015-12-11 20:10:57Z

Okay, the solution was pretty obvious, once I sussed it out. Much thanks to @shennan for getting me going.

The key is:

as @shennan mentioned, you don't work with returns, as we're working asynchronously. This means callbacks

and

You have to trigger callbacks for each part of the function. This is not possible with just one function, so to get the objects returning you need two, each doing different parts of the original function.

Here's what I've come up with. Hope someone can look it over and give me an opinion...

        // Main processing function. 
        var subNodeProc = function(nodeList,sqlP,itteration_count,cback) {
            var async = require('async');

            itteration_count--;
            async.each(nodeList,function(dd,cb){

                if (itteration_count > 0) {

                    // Trigger SQL Walker subNodeProcWalker with the necessary data (dd.node_id in this case, with a callback)
                    subNodeProcWalker(dd.node_id,sqlP,itteration_count,function(nl) {

                        // Hey look! the walker has done its business. Time to fill the subnode and tell async we're done with this array node.
                        dd.subnodes = nl;
                        cb();

                    });

                }

            },function(){

                // At the end of the run, return the nodelist intact.
                cback(nodeList);

            });

        }


        // SQL Walker with callback for subNodeProc
        var subNodeProcWalker = function(node_id,sqlP,itteration_count,cback){

            // assemble the object for the query and do the query
            var simple = {
                sql:sqlP,
                values:[node_id],
                timeout:40000
            };
            connection.query(simple, function(err,rslt){
                if (err) {

                    console.log('Error in Query');
                    console.log(simple);
                    console.log(err);
                    cback(false);

                } else {

                    // no error and a result? Quick! Trigger subNodeProc again
                    if (rslt.length > 0) {

                        subNodeProc(rslt,sqlP,itteration_count,function(nodePol) {

                            // Lookie lookie! A result from subNodeProc! There's life there! Quick! tell this function we're done!
                            cback(nodePol);
                        });

                    } else {

                        cback(false);

                    }

                }

            });
        }

Collectives™ on Stack Overflow

nodejs, mysql, async itterative functions

2 Answers 2

4 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related