mongo agrégat basé sur les conditions pour filtrer le document pour la gestion des versions

J'ai pu résoudre ce problème avec la requête agrégée suivante,

• Nous jobUuid abord les résultats correspondant uniquement au jobUuid fourni par l'utilisateur ou au "default" dans la section match.

• Ensuite, les résultats sont regroupés en fonction de l'uuid, en utilisant une phase de groupes et nous comptons également les résultats.

• En utilisant les conditions de replaceRoot nous replaceRoot abord la longueur du document groupé,

• Si la longueur du document groupé est supérieure ou égale à 2, nous filtrons le document qui correspond au jobUuid fourni.

• S'il est inférieur ou égal à 1, nous vérifions s'il correspond au jobUuid default et le retournons.

La requête est ci-dessous:

[
    {
      $match: {
        $or: [{ jobUuid:1 },{ jobUuid: 'default'}]
      }
    },
    {
      $group: {
        _id: '$uuid',
        count: {
          $sum: 1
        },
        docs: {
          $push: '$$ROOT'
        }
      }
    },
    {
      $replaceRoot: {
        newRoot: {
          $cond: {
            if: {
              $gte: [
                '$count',
                2
              ]
            },
            then: {
              $arrayElemAt: [
                {
                  $filter: {
                    input: '$docs',
                    as: 'item',
                    cond: {
                      $ne: [
                        '$$item.jobUuid',
                        'default'
                      ]
                    }
                  }
                },
                0
              ]
            },
            else: {
              $arrayElemAt: [
                {
                  $filter: {
                    input: '$docs',
                    as: 'item',
                    cond: {
                      $eq: [
                        '$$item.jobUuid',
                        'default'
                      ]
                    }
                  }
                },
                0
              ]
            }
          }
        }
      }
    }
  ]

Voici ce que je ferais:

1. match stage avec $ in plutôt qu'un $ or (pour plus de lisibilité)
2. phase de groupe avec _id sur $ uuid, comme vous l'avez fait, mais au lieu de pousser toutes les données dans un tableau, soyez plus sélectif. _id stocke déjà $ uuid, donc aucune raison de le capturer à nouveau. Le nom doit toujours être le même pour chaque $ uuid, donc ne prenez que la première instance. Sur la base de la correspondance, il n'y a que deux possibilités pour jobUuid, mais cela supposera que ce sera soit "default" ou autre chose, et qu'il peut y avoir plus d'une occurrence du jobUuid non "default". En utilisant "$ addToSet" au lieu de pousser vers un tableau au cas où il y aurait plusieurs occurrences du même jobUuid pour un utilisateur, aussi, avant d'ajouter à l'ensemble, utilisez un conditionnel pour ajouter uniquement des jobUuids non "par défaut", en utilisant $$ REMOVE pour éviter d'insérer un null lorsque le jobUuid est "default".
3. Enfin, "$ project" pour nettoyer les choses. Si l'élément 0 du tableau jobUuids n'existe pas (est nul), il n'y a pas d'autre possibilité pour cet utilisateur que pour le jobUuid d'être "default", donc utilisez "$ ifNull" pour tester et définir "default" comme il convient. Il peut y avoir plus d'un jobUuid ici, selon si cela est autorisé dans votre base de données / application, à vous de décider comment gérer cela (prendre le plus élevé, prendre le plus bas, etc.).

Testé sur: https://mongoplayground.net/p/e76cVJf0F3o

[{
    "$match": {
        "jobUuid": {
            "$in": [
                "1",
                "default"
            ]
        }
    }
},
{
    "$group": {
        "_id": "$uuid",
        "name": {
            "$first": "$name"
        },
        "jobUuids": {
            "$addToSet": {
                "$cond": {
                    "if": {
                        "$ne": [
                            "$jobUuid",
                            "default"
                        ]
                    },
                    "then": "$jobUuid",
                    "else": "$$REMOVE"
                }
            }
        }
    }
},
{
    "$project": {
        "_id": 0,
        "uuid": "$_id",
        "name": 1,
        "jobUuid": {
            "$ifNull": [{
                    "$arrayElemAt": [
                        "$jobUuids",
                        0
                    ]
                },
                "default"
            ]
        }
    }
}]

Mise à jour basée sur un commentaire:

mais les UUID sont des chaînes alphanumériques, comme indiqué ci-dessus, cela a-t-il un effet sur ces tri, et comme nous n'utilisons pas de conditions pour obtenir les résultats, je crains que cela ne pose des problèmes.

Vous pouvez utiliser un champ supplémentaire pour faire correspondre l'ordre de tri afin qu'il soit du même ordre que les valeurs de l'expression in. Assurez-vous de fournir les valeurs par défaut comme dernière valeur.

[
  {"$match":{"jobUuid":{"$in":[1,"default"]}}},
  {"$sort":{"uuid":1, "jobUuid":1}},
  {
    "$group": {
      "_id": "$uuid",
      "doc":{"$first":"$$ROOT"}
    }
  },
  {"$replaceRoot":{"newRoot":"$doc"}}
]

exemple ici - https://mongoplayground.net/p/wXiE9i18qxf

Original

Vous pouvez utiliser la requête ci-dessous. La requête choisira le document non par défaut s'il existe pour uuid ou bien choisir le document par défaut comme seul document.

[
  {"$match":{"jobUuid":{"$in":["d275781f-ed7f-4ce4-8f7e-a82e0e9c8f12","default"]}}},
  {"$addFields":{ "order":{"$indexOfArray":[["d275781f-ed7f-4ce4-8f7e-a82e0e9c8f12","default"], "$jobUuid"]}}},
  {"$sort":{"uuid":1, "order":1}},
  {
    "$group": {
      "_id": "$uuid",
      "doc":{"$first":"$$ROOT"}
    }
  },
  {"$project":{"doc.order":0}},
  {"$replaceRoot":{"newRoot":"$doc"}}
]

exemple ici - https://mongoplayground.net/p/KrL-1s8WCpw