CODEWITHSUNDEEP
dc.jscrossfilter
Polantaris
Polantaris

Reputation: 99

group.all() call required for data to populate correctly

So I've encountered a weird issue when dealing with making Groups based on a variable when the crossfilter is using an array, instead of a literal number.

I currently have an output array of a date, then 4 values, that I then map into a composite graph. The problem is that the 4 values can fluctuate depending on the input given to the page. What I mean is that based on what it receives, I can have 3 values, or 10, and there's no way to know in advance. They're placed into an array which is then given to a crossfilter. When in testing, I was accessing using

dimension.group.reduceSum(function(d) { return d[0]; });

Where 0 was changed to whatever I needed. But I've finished testing, for the most part, and began to adapt it into a dynamic system where it can change, but there's always at least the first two. To do this I created an integer that keeps track of what index I'm at, and then increases it after the group has been created. The following code is being used:

var range = crossfilter(results);
var dLen = 0;
var curIndex = 0;
var dateDimension = range.dimension(function(d) { dLen = d.length; return d[curIndex]; });
curIndex++;
var aGroup = dateDimension.group().reduceSum(function(d) { return d[curIndex]; });
curIndex++;
var bGroup = dateDimension.group().reduceSum(function(d) { return d[curIndex]; });
curIndex++;
var otherGroups = [];
for(var h = 0; h < dLen-3; h++) {
    otherGroups[h] = dateDimension.group().reduceSum(function(d) { return d[curIndex]; });
    curIndex++;
}
var charts = [];
for(var x = 0; x < dLen - 3; x++) {
    charts[x] = dc.barChart(dataGraph)
        .group(otherGroups[x], "Extra Group " + (x+1))
        .hidableStacks(true)
}
charts[charts.length] = dc.lineChart(dataGraph)
    .group(aGroup, "Group A")
    .hidableStacks(true)
charts[charts.length] = dc.lineChart(dataGraph)
    .group(aGroup, "Group B")
    .hidableStacks(true)

The issue is this: The graph gets built empty. I checked the curIndex variable multiple times and it was always correct. I finally decided to instead check the actual group's resulting data using the .all() method.

The weird thing is that AFTER I used .all(), now the data works. Without a .all() call, the graph cannot determine the data and outputs absolutely nothing, however if I call .all() immediately after the group has been created, it populates correctly.

Each Group needs to call .all(), or only the ones that do will work. For example, when I first was debugging, I used .all() only on aGroup, and only aGroup populated into the graph. When I added it to bGroup, then both aGroup and bGroup populated. So in the current build, every group has .all() called directly after it is created.

Technically there's no issue, but I'm really confused on why this is required. I have absolutely no idea what the cause of this is, and I was wondering if there was any insight into it. When I was using literals, there was no issue, it only happens when I'm using a variable to create the groups. I tried to get output later, and when I do I received NaN for all the values. I'm not really sure why .all() is changing values into what they should be especially when it only occurs if I do it immediately after the group has been created.

Below is a screenshot of the graph. The top is when everything has a .all() call after being created, while the bottom is when the Extra Groups (the ones defined in the for loop) do not have the .all() call anymore. The data is just not there at all, I'm not really sure why. Any thoughts would be great.

https://i.sstatic.net/0j1ey.jpg

Upvotes: 1

Views: 927

Answers (1)

Gordon
Gordon

Reputation: 20120

It looks like you may have run into the classic "generating lambdas from loops" JavaScript problem.

You are creating a whole bunch of functions that reference curIndex but unless you call those functions immediately, they will refer to the same instance of curIndex in the global environment. So if you call them after initialization, they will probably all try to use a value which is past the end.

Instead, you might create a function which generates your lambdas, like so:

function accessor(curIndex) {
    return function(d) { return d[curIndex]; };
}

And then each time call .reduceSum(accessor(curIndex))

This will cause the value of curIndex to get copied each time you call the accessor function (or you can think of each generated function as having its own environment with its own curIndex).

Upvotes: 1

Related Questions