jq: Add nested numbers? - json

Question

In jq, how can I add numbers that are nested in streamed objects?
Example:
{"game":
{"player1": {"score": 2}}}
{"game":
{"player1": {"score": 4}}}
I can add these numbers using two jq calls:
$ cat foo.json | jq '.game.player1.score' | jq --slurp 'add'
6
How can it be done with one jq call?
Also, how to add the scores of two different players separately?
{"game":
{"player1": {"score": 2},
"player2": {"score": 20}}}
{"game":
{"player1": {"score": 4},
"player2": {"score": 40}}}
$ cat foo.json | jq '???'
{"player1": 6, "player2": 60}

Answer 1

First, here's a variant of #OguzIsmail's first solution to the first problem. It serves to validate the usefulness of the generic function:
def sigma(s): reduce s as $x (0; .+$x);
With this, and using the -n command-line option, the solution to the given problem is simply:
sigma(inputs.game.player1.score)
Second problem
In the same vein of genericity:
def sigmas(stream; f):
reduce stream as $s (null;
[., ($s | f)] | transpose | map(add));
sigmas(inputs | .game; [.player1.score, .player2.score])
| {player1: .[0], player2: .[1]}
Notice that sigmas as defined here can handle arbitrarily many summands. A still more generic solution, avoiding the need to specify the summands as a list, is left as an (easy) exercise for the reader :-)
jq.jq
Typically, generic functions can be included in a "standard jq library". For example, if your utility functions are in ~/.jq/jq.jq, then assuming the pwd does not have a different jq.jq, you could write (for the solution to the first problem):
jq -n 'include "jq"; sigma(inputs.game.player1.score)' foo.json
Robust inclusion of a library
To avoid difficulties associated with module paths, it sometimes makes sense to specify the path within the include or import directive, e.g.:
jq -n 'include "jq" {search: "~/jq"}; ...'

Answer 2

One option is to use reduce, e.g:
jq -n 'reduce inputs.game.player1.score as $score (0; . + $score)' file
Another one is:
jq -n '[inputs.game.player1.score] | add' file
But this is would not perform as well as the first with large inputs.
And here is a more generic one covering the second Q too
jq -n 'reduce inputs.game as $game ({};
reduce ($game|keys_unsorted)[] as $player (.;
.[$player] += $game[$player].score
)
)' file

Answer 3

Here's a generic solution that arises from the perspective that the stream of objects defines a table (i.e., a spreadsheet). The solution is also efficient (no slurping) and robust (no assumptions about the ordering or presence of keys).
# The stream is assumed to consist of objects (or else arrays)
# in which same-named keys have compatible values under `+`.
# The resultant object (or array) has keys the values of which are
# the sum of the values of the corresponding keys of the
# input objects, which thus need not have the same keys.
def add_by_column(stream):
def add(b): reduce (b|keys_unsorted[]) as $k
(.; .[$k] += b[$k]);
reduce stream as $x (null; add($x));
add_by_column(inputs | .game | map_values(.score) )
Notice that this assumes that the -n command-line option is used.

Answer 4

Here's an solution with a helper function which uses
Update assignment |= to flatten {"player1": {"score": 4}} objects to {"player1": 4}
to_entries[] to convert the rows to a canonical {"key":"player1", "value": 2} form
Once the rows are in canonical form a simple Reduce does the final aggregation.
def kvrows: inputs[] | .[] |= .[] | to_entries[] ; # {"key":"player1","value": 2}...
reduce kvrows as $e ({}; .[$e.key] += $e.value) # compute sums
Sample execution assuming the above in test.jq and data in test.json
$ jq -Mn -f test.jq test.json
{
"player1": 6,
"player2": 60
}