不在数组中的文档的mongodb默认值

不在数组中的文档的mongodb默认值,mongodb,mongodb-query,Mongodb,Mongodb Query,我需要在数组中选择id[1,2,3,4,5], 如果没有Id为3和5的文档,我需要此文档的默认名称 比如说 {id:1,name:a} {id:2,name:b} {id:4,name:c} 询问某事 find ... id:{$in:{1,2,3,4,5}}}) -> 结果应该是 {id:1,name:a} {id:2,name:b} {id:3,name:defaultvalue} {id:4,name:c} {id:5,name:defaultvalue} 我想要3和5的默认值

我需要在数组中选择id
[1,2,3,4,5]
, 如果没有Id为
3和5的文档,我需要此文档的默认名称

比如说

{id:1,name:a}
{id:2,name:b}
{id:4,name:c}

询问某事

find ... id:{$in:{1,2,3,4,5}}})
-> 结果应该是

{id:1,name:a}
{id:2,name:b}
{id:3,name:defaultvalue}
{id:4,name:c}
{id:5,name:defaultvalue}

我想要3和5的默认值

我该如何查询??
请帮助

您可以使用

  • 我首先创建了两个阵列:
    • missingIDs
      查找文档中不存在的缺失ID
    • 将文档匹配到数组[1,2,3,4,5]中的所有可用文档
  • 然后连接这两个数组,如果为null,则与一起使用以添加名称字段
  • 尝试以下聚合查询:

    db.collection.aggregate([
      {
        $facet: {
          missingIDs: [
            {
              $group: {
                _id: null,
                ids: {
                  $push: {
                    id: "$id"
                  }
                }
              }
            },
            {
              $project: {
                _id: 0,
                ids: {
                  $setDifference: [
                    [
                      {
                        id: 1
                      },
                      {
                        id: 2
                      },
                      {
                        id: 3
                      },
                      {
                        id: 4
                      },
                      {
                        id: 5
                      }
                    ],
                    "$ids"
                  ]
                }
              }
            },
            {
              $unwind: "$ids"
            },
            {
              $project: {
                id: "$ids.id"
              }
            }
          ],
          matchedDocuments: [
            {
              $match: {
                id: {
                  $in: [
                    1,
                    2,
                    3,
                    4,
                    5
                  ]
                }
              }
            },
            {
              $project: {
                id: 1,
                name: 1,
                _id: 0
              }
            }
          ]
        }
      },
      {
        "$project": {
          concat: {
            "$concatArrays": [
              "$matchedDocuments",
              "$missingIDs"
            ]
          }
        }
      },
      {
        $unwind: "$concat"
      },
      {
        "$addFields": {
          "concat.name": {
            "$ifNull": [
              "$concat.name",
              "defaultvalue"
            ]
          }
        }
      },
      {
        $project: {
          id: "$concat.id",
          name: "$concat.name",
          
        }
      },
      {
        "$sort": {
          id: 1
        }
      }
    ])
    

    您可以使用

  • 我首先创建了两个阵列:
    • missingIDs
      查找文档中不存在的缺失ID
    • 将文档匹配到数组[1,2,3,4,5]中的所有可用文档
  • 然后连接这两个数组,如果为null,则与一起使用以添加名称字段
  • 尝试以下聚合查询:

    db.collection.aggregate([
      {
        $facet: {
          missingIDs: [
            {
              $group: {
                _id: null,
                ids: {
                  $push: {
                    id: "$id"
                  }
                }
              }
            },
            {
              $project: {
                _id: 0,
                ids: {
                  $setDifference: [
                    [
                      {
                        id: 1
                      },
                      {
                        id: 2
                      },
                      {
                        id: 3
                      },
                      {
                        id: 4
                      },
                      {
                        id: 5
                      }
                    ],
                    "$ids"
                  ]
                }
              }
            },
            {
              $unwind: "$ids"
            },
            {
              $project: {
                id: "$ids.id"
              }
            }
          ],
          matchedDocuments: [
            {
              $match: {
                id: {
                  $in: [
                    1,
                    2,
                    3,
                    4,
                    5
                  ]
                }
              }
            },
            {
              $project: {
                id: 1,
                name: 1,
                _id: 0
              }
            }
          ]
        }
      },
      {
        "$project": {
          concat: {
            "$concatArrays": [
              "$matchedDocuments",
              "$missingIDs"
            ]
          }
        }
      },
      {
        $unwind: "$concat"
      },
      {
        "$addFields": {
          "concat.name": {
            "$ifNull": [
              "$concat.name",
              "defaultvalue"
            ]
          }
        }
      },
      {
        $project: {
          id: "$concat.id",
          name: "$concat.name",
          
        }
      },
      {
        "$sort": {
          id: 1
        }
      }
    ])
    

    管道按顺序包含以下阶段-

  • id
    字段开始
  • 没有任何设置,因此您可以将结果输入到中,以便稍后进行设置比较
  • 找到缺少的内容,并将其附加到
    $addFields
    阶段中的临时结果集
  • 立即投影匹配和缺失的值
  • 将两者都放在一个数组中并将其投影
  • 阵列
  • 这样你就可以得到你想要的平面结构
  • 通过
    id
    字段

  • 这是供您参考的管道-

    var idArr = [
        1,
        2,
        3,
        4,
        5
    ];
    
    db.collection.aggregate([
        {
            $match: {
                id: {
                    $in: idArr
                }
            }
        },
        {
            $group: {
                _id: null,
                grouping: {
                    $push: '$$ROOT'
                }
            }
        },
        {
            $addFields: {
                missingVals: {
                    $setDifference: [
                        idArr,
                        {
                            $map: {
                                input: '$grouping',
                                as: 'item',
                                in: '$$item.id'
                            }
                        }
                    ]
                }
            }
        },
        {
            $project: {
                result1: {
                    $map: {
                        input: '$grouping',
                        as: 'item',
                        in: {
                            id: '$$item.id',
                            name: '$$item.name'
                        }
                    }
                },
                result2: {
                    $map: {
                        input: '$missingVals',
                        as: 'item',
                        in: {
                            id: '$$item',
                            name: ''
                        }
                    }
                }
            }
        },
        {
            $project: {
                result: {
                    $concatArrays: ['$result1', '$result2']
                }
            }
        },
        {
            $unwind: '$result'
        },
        {
            $replaceRoot: {
                newRoot: '$result'
            }
        },
        {
            $sort: {
                id: 1
            }
        }
    ]);
    
    输出-

    [
      {
        "id": 1,
        "name": "a"
      },
      {
        "id": 2,
        "name": "b"
      },
      {
        "id": 3,
        "name": ""
      },
      {
        "id": 4,
        "name": "c"
      },
      {
        "id": 5,
        "name": ""
      }
    ]
    

    管道按顺序包含以下阶段-

  • id
    字段开始
  • 没有任何设置,因此您可以将结果输入到中,以便稍后进行设置比较
  • 找到缺少的内容,并将其附加到
    $addFields
    阶段中的临时结果集
  • 立即投影匹配和缺失的值
  • 将两者都放在一个数组中并将其投影
  • 阵列
  • 这样你就可以得到你想要的平面结构
  • 通过
    id
    字段

  • 这是供您参考的管道-

    var idArr = [
        1,
        2,
        3,
        4,
        5
    ];
    
    db.collection.aggregate([
        {
            $match: {
                id: {
                    $in: idArr
                }
            }
        },
        {
            $group: {
                _id: null,
                grouping: {
                    $push: '$$ROOT'
                }
            }
        },
        {
            $addFields: {
                missingVals: {
                    $setDifference: [
                        idArr,
                        {
                            $map: {
                                input: '$grouping',
                                as: 'item',
                                in: '$$item.id'
                            }
                        }
                    ]
                }
            }
        },
        {
            $project: {
                result1: {
                    $map: {
                        input: '$grouping',
                        as: 'item',
                        in: {
                            id: '$$item.id',
                            name: '$$item.name'
                        }
                    }
                },
                result2: {
                    $map: {
                        input: '$missingVals',
                        as: 'item',
                        in: {
                            id: '$$item',
                            name: ''
                        }
                    }
                }
            }
        },
        {
            $project: {
                result: {
                    $concatArrays: ['$result1', '$result2']
                }
            }
        },
        {
            $unwind: '$result'
        },
        {
            $replaceRoot: {
                newRoot: '$result'
            }
        },
        {
            $sort: {
                id: 1
            }
        }
    ]);
    
    输出-

    [
      {
        "id": 1,
        "name": "a"
      },
      {
        "id": 2,
        "name": "b"
      },
      {
        "id": 3,
        "name": ""
      },
      {
        "id": 4,
        "name": "c"
      },
      {
        "id": 5,
        "name": ""
      }
    ]
    

    • $match
      您的ID
      $in
      状态
    • $group
      按null排序,并生成所有根对象和ID的数组
    • $reduce
      以ID数组的形式输入,以对象的根数组的形式输入初始值
      • 检查ids数组中id的条件,然后以其他方式返回当前值添加新的默认对象并使用
        root
        数组使用
        $concatarray
    • $unwind
      解构根数组
    • $replaceWith
      替换根目录中的根对象

    • $match
      您的ID
      $in
      状态
    • $group
      按null排序,并生成所有根对象和ID的数组
    • $reduce
      以ID数组的形式输入,以对象的根数组的形式输入初始值
      • 检查ids数组中id的条件,然后以其他方式返回当前值添加新的默认对象并使用
        root
        数组使用
        $concatarray
    • $unwind
      解构根数组
    • $replaceWith
      替换根目录中的根对象