Cartesian product between arrays

[PieroM97]

Hello Everyone,

I am currently facing a challenge with a transformation task involving JSON data using JSLT. My goal is to perform a task similar to calculating a cartesian product with the values of the JSON object.

Here's the problem in detail:

Given the following JSON:

{
      "first":["A","B"],
      "second":["C","D"],
      "third": [ "E", "F", "G" ]
}

I aim to concatenate all the values like in a cartesian product, yielding a result like this:

{
  "first_second_third": ["ACE", "BCE", .... ]
}

The input fields are not necessarily guaranteed. The object can contain one field or multiple fields.

So far, I have attempted the following approach:

let fields_filter = join([for(.) .key],"_")

let value_filter = [for(.) .value]

{
  $fields_filter : $value_filter
}

Which gives me the following result:

{
  "first_second_third" : [ [ "A", "B" ], [ "C", "D" ], [ "E", "F", "G" ] ]
}

I was considering iterating over each sub-array, but I'm finding myself at a crossroads given JSLT's limitations. Hence, I'd highly appreciate any insights on how to approach this problem within the capabilities of JSLT.

Thank you in advance for your assistance!

[larsga]

I was considering iterating over each sub-array

I think that's exactly what you need to do. The question is how.

If you know the names of the potential keys you could just write out a set of nested loops. The difficulty is handling missing keys, but I would do that by iterating over [ "" ] when a key is missing.

If the number of arrays is unknown I think you need to write a recursive function to do it.

but I'm finding myself at a crossroads given JSLT's limitations.

It does have limitations, of course, but I'm not sure those are relevant here in any way. You'd have much the same challenges in any programming language. If you think of it that way, it might perhaps help. How would you write this in your preferred, ordinary programming language? The same approach would likely work in JSLT.

[PieroM97]

Hi, first of all, thanks for your answer.

I had the same idea of testing this with other programming languages ( and even pseudocode ) and yes, finally the problem remain challenging anyway.

I will focus only in the creation of the final array :

first = [ "A", "B" ]
second = ["C", "D"]
third = ["E","F", "G"]

res = []

for f in first :
  for s in second: 
      for t in third: 
          res.append(f +"/"+ s + "/"+ t)
          
print(res)

In python given the three arrays, i can iterate with a few nested loops.

['A/C/E', 'A/C/F', 'A/C/G', 'A/D/E', 'A/D/F', 'A/D/G', 'B/C/E', 'B/C/F', 'B/C/G', 'B/D/E', 'B/D/F', 'B/D/G']

To make this recursive

first_second_third =  [ first, second, third ]

def combine(input_list):
    combinations = []
    if len(input_list) == 0:
        return ['']
    else:
        first_array = input_list.pop(0)
        sub_combinations = combine(input_list)
        for element in first_array:
            for sub_combination in sub_combinations:
                combinations.append(element + '/' + sub_combination)
    return combinations

print(combine(first_second_third))

which will give me the same result.

Going back to JSLT I have problems even using the nested loops. I am probably using the wrong approach 😓:

let fields_name = join([for(.) .key],"_")


let third = [for (.third) .]

let second_third = [for (.second) . + "/" +  $third ]

let first_second_third = [for (.first) . + $second_third]



{
  $fields_name : $first_second_third  
}

The result is:

"first_second_third" : [ "A/[\"C/[\\\"E\\\",\\\"F\\\",\\\"G\\\"]\",\"D/[\\\"E\\\",\\\"F\\\",\\\"G\\\"]\"]", "B/[\"C/[\\\"E\\\",\\\"F\\\",\\\"G\\\"]\",\"D/[\\\"E\\\",\\\"F\\\",\\\"G\\\"]\"]" ]

Any suggestions that could help me get unblocked?

Thanks again

[PieroM97]

Okay, I found out how to do it using nested loops, basic case, when all the elements exists ( first, second, three ) .

Here my solution:

INPUT:

{
      "first":["A","B"],
      "second":["C","D"],
      "third": [ "E", "F", "G" ]
}

JSLT :

let fields_name = join([for(.) .key],"_")

def extract_third(third)
  [for($third) . ]

let first = flatten([for (.first) .])


let second_third = flatten([
                      
                          for (.second)
                            let parent = (.)
                             [
                               for ($first) . + $parent]
                                                     ])

let first_second_third = flatten([
                      
                          for (.third)
                            let parent = (.)
                             [
                               for ($second_third ) . + $parent]
                                                     ])




{
  $fields_name : $first_second_third 
}

Result:

{
  "first_second_third" : [ "ACE", "BCE", "ADE", "BDE", "ACF", "BCF", "ADF", "BDF", "ACG", "BCG", "ADG", "BDG" ]
}

Now next step are :

• check the existence of one of the three elements, iterate on [""] if it doesn't exist
• try recursive 🥲

[larsga]

This let third = [for (.third) .] is the same as simply let third = .third.

On the second let you get into trouble: . + "/" + $third. You're concatenating two strings with an array, so the array is converted to a string. You are not actually nesting the loops.

This is nesting loops:

let third = (.third)
[for (.second) 
  let item2 = (.)
  [for ($third) $item2 + "/" + .]

The parentheses are there because of weirdness in the JSLT syntax. The reason you can't refer to .third directly is that when you're iterating over the .second the context node is the current value you've iterated to, and no longer the input object. Declaring the $third gets around that.

[PieroM97]

Thanks @larsga , i start too see more clear now.

At the moment i can use nested and exception on missing key to solve the problem partially ( in the case of maximum 3 known values ):

Here the code:

let fields_name = join([for(.) if(.value) .key],"_")


let first = flatten(if (.first) [for (.first) .] else [""] )


let second_first= flatten(if(.second)[
                      for (.second)
                            let parent = (.)
                             [for ($first) . + "/" +$parent]] else [""])

let first_second_third = flatten(
                           if(.third)[
                          for (.third)
                            let parent = (.)
                             [for ($second_first) . + "/" + $parent]] else[""])



{
  $fields_name : $first_second_third 
}

With this the only problem is in this case:

INPUT:

{
      "first":["A","B"],
      "third": [ "E", "F", "G" ]
}

Since we are veryifing into each inner loop the existence of the previous element, and this elements are ordered, if one element is missing in the middle, the loop is kind interrupted earlier:

OUTPUT:

{
  "first_third" : [ "/E", "/F", "/G" ]
}

while the expected output should be the cartesian product of first and third 🥲. I still think that the recursive is the best solution but absolutely not the easiest one 🤯

[PieroM97]

In this case ( field second is missing ) it would better to return the "parent" object like this:

let fields_name = join([for(.) if(.value) .key],"_")

let third = if(.third) .third else [""]

let second_third = flatten(if(.second)[for (.second) 
                    let parent = (.)
                    [for ($third) $parent + "/" + .]] else $third )



let first_second_third = flatten(if(.first)[for (.first) 
                          let parent = (.)
                          [for ($second_third ) $parent + "/" + .]] else $second_third)


{
  $fields_name : $first_second_third 
}