MongoDb Aggregation Datamanipulation

Forespørgsel

det er en aggregeringsopdatering, selvom pipeline ikke tillader os at bruge stadier som gruppeopslag osv., der bruges her. (du kan bruge $out og erstat samling efter eller $merge for at erstatte dokumenter (svarende til opdatering))
første kort
- for hvert træk (dokument medlem af træk), gør det det til array
  [["trait_type": "type"] ["value": "Male"] ["display_type": null] ...]
- reducer på det array for kun at konstruere 1 dokument ud fra dem
  {"type" "type","value" :"Male"} (gør det også små bogstaver og "_")

Nu træk det samme

"traits": [
  {
    "type": "type",
    "value": "Male"
  },
  {
    "type": "accessory",
    "value": "Mohawk"
  },
  {
    "type": "accessory",
    "value": "Earring"
  },
  {
    "type": "accessory",
    "value": "Frown"
  }
]

opslag med dummy-samlingen [{}] (det gør vi for at lave en gruppe inde i det array) det er ligesom et trick, der giver os mulighed for at bruge sceneoperatorer i 1 dokument
- opslagspipeline afvikles og grupperes efter type
```
"traits": [
  {
    "values": [
      "Mohawk",
      "Earring",
      "Frown"
    ],
    "type": "accessory"
  },
  {
    "values": [
      "Male"
    ],
    "type": "type"
  }
]
```
- så er det en erstatningsrod, der skal tage værdien af type, gør den til feltnavnet og værdierne som værdien (if size=1 removes the array)

Efter opslag har vi

"traits": [
  {
    "accessory": [
      "Mohawk",
      "Earring",
      "Frown"
    ]
  },
  {
    "type": "Male"
  }
]

så alt vi skal gøre er at reducere disse egenskaber og flette objekterne (nøgler er alligevel unikke, fordi vi grupperede efter dem)
og vi får det forventede output (i det mindste synes jeg det er ok)

Testkode her

db.collection.aggregate([
  {
    "$set": {
      "traits": {
        "$map": {
          "input": "$traits",
          "as": "t",
          "in": {
            "$reduce": {
              "input": {
                "$map": {
                  "input": {
                    "$objectToArray": "$$t"
                  },
                  "as": "m",
                  "in": [
                    "$$m.k",
                    "$$m.v"
                  ]
                }
              },
              "initialValue": {},
              "in": {
                "$let": {
                  "vars": {
                    "type_value": "$$value",
                    "ta": "$$this"
                  },
                  "in": {
                    "$let": {
                      "vars": {
                        "key": {
                          "$arrayElemAt": [
                            "$$ta",
                            0
                          ]
                        },
                        "value": {
                          "$arrayElemAt": [
                            "$$ta",
                            1
                          ]
                        }
                      },
                      "in": {
                        "$switch": {
                          "branches": [
                            {
                              "case": {
                                "$eq": [
                                  "$$key",
                                  "value"
                                ]
                              },
                              "then": {
                                "$mergeObjects": [
                                  "$$type_value",
                                  {
                                    "value": "$$value"
                                  }
                                ]
                              }
                            },
                            {
                              "case": {
                                "$eq": [
                                  "$$key",
                                  "trait_type"
                                ]
                              },
                              "then": {
                                "$mergeObjects": [
                                  "$$type_value",
                                  {
                                    "type": {
                                      "$replaceAll": {
                                        "input": {
                                          "$toLower": "$$value"
                                        },
                                        "find": " ",
                                        "replacement": "_"
                                      }
                                    }
                                  }
                                ]
                              }
                            }
                          ],
                          "default": "$$type_value"
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  {
    "$lookup": {
      "from": "dummy",
      "let": {
        "traits": "$traits"
      },
      "pipeline": [
        {
          "$set": {
            "traits": "$$traits"
          }
        },
        {
          "$unwind": {
            "path": "$traits"
          }
        },
        {
          "$replaceRoot": {
            "newRoot": "$traits"
          }
        },
        {
          "$group": {
            "_id": "$type",
            "values": {
              "$push": "$value"
            }
          }
        },
        {
          "$set": {
            "type": "$_id"
          }
        },
        {
          "$project": {
            "_id": 0
          }
        },
        {
          "$replaceRoot": {
            "newRoot": {
              "$cond": [
                {
                  "$eq": [
                    {
                      "$size": "$values"
                    },
                    1
                  ]
                },
                {
                  "$arrayToObject": {
                    "$let": {
                      "vars": {
                        "pair": [
                          [
                            "$type",
                            {
                              "$arrayElemAt": [
                                "$values",
                                0
                              ]
                            }
                          ]
                        ]
                      },
                      "in": "$$pair"
                    }
                  }
                },
                {
                  "$arrayToObject": {
                    "$let": {
                      "vars": {
                        "pair": [
                          [
                            "$type",
                            "$values"
                          ]
                        ]
                      },
                      "in": "$$pair"
                    }
                  }
                }
              ]
            }
          }
        }
      ],
      "as": "traits"
    }
  },
  {
    "$set": {
      "traits": {
        "$mergeObjects": "$traits"
      }
    }
  }
])

MongoDb Aggregation Datamanipulation - Objekter til Arrays