比较在 Mongodb 中存储为字符串的整数

Question

在下面的集合中，“数量”列包含整数值，但数据类型是字符串。

我想将“数量”字段与聚合中的整数进行比较，将“仓库”字段与字符串“A”进行比较。 ("数量" > 2 和 "仓库" = "A")

[无法将集合中的数据类型更改为整数，因为存在巨大的依赖关系]

编辑：需要检索所有列和所有符合条件的文档。

查询：得到不正确的结果

db.runCommand(
    {
        aggregate: "products", pipeline: [
            {
                $match: {
                    instock: {
                        $elemMatch: {
                            warehouse: "A",
                            qty: { $gt: "2" }
                        }
                    }
                }
            },
            { $project: { _id: 0 } }],
        cursor: { batchSize: 200 }
    });

结果：虽然满足条件，但没有得到 item = journal 的文档

/* 1 */
{
    "item" : "paper",
    "instock" : [
        {
            "warehouse" : "A",
            "qty" : "60"
        },
        {
            "warehouse" : "B",
            "qty" : "15"
        }
    ]
},

/* 2 */
{
    "item" : "planner",
    "instock" : [
        {
            "warehouse" : "A",
            "qty" : "22"
        },
        {
            "warehouse" : "B",
            "qty" : "5"
        }
    ]
}

产品集合

[
    {
        "item": "journal",
        "instock": [
            {
                "warehouse": "A",
                "qty": "11"
            },
            {
                "warehouse": "C",
                "qty": "15"
            }
        ]
    },
    {
        "item": "paper",
        "instock": [
            {
                "warehouse": "A",
                "qty": "60"
            },
            {
                "warehouse": "B",
                "qty": "15"
            }
        ]
    },
    {
        "item": "planner",
        "instock": [
            {
                "warehouse": "A",
                "qty": "22"
            },
            {
                "warehouse": "B",
                "qty": "5"
            }
        ]
    }
]

在这种情况下，将不正确的结果作为大于运算符按字典顺序工作，但它应该像整数一样工作。虽然我尝试将其转换为双倍，但我没有得到任何结果。

使用 $convert to double 进行查询：没有结果

db.runCommand(
    {
        aggregate: "products", pipeline: [
            //{ $match: { "item": { $in: ["planner", "paper","journal"] } } },
            {
                $match: {
                    instock: {
                        $elemMatch: {
                            warehouse: "A",
                            qty: {
                                $gt: [
                                    {$convert:{ input: "$qty", to: "double" }}, 5]
                            }
                        }
                    }
                }
            },
            { $project: { _id: 0 } }],
        cursor: { batchSize: 200 }
    });

Answer 1

试试这个：

db.products.aggregate([
  {
    $unwind: "$instock"
  },
  {
    $match: {
      $expr: {
        $and: [
          {
            $eq: [
              "$instock.warehouse",
              "A"
            ]
          },
          {
            $gt: [
              {
                $toInt: "$instock.qty"
              },
              2
            ]
          }
        ]
      }
    }
  },
  {
    $group: {
      _id: "$_id",
      item: {
        $first: "$item"
      },
      instock: {
        $push: "$instock"
      }
    }
  },
  {
    $project: {
      _id: 0
    }
  }
])

MongoPlayground

Answer 2

试试这个，它使用$filter 来保留有条件的对象：

db.runCommand(
    {
        aggregate: "products", pipeline: [
            { $match: { 'instock.warehouse': 'A' } },
            {
                $addFields: {
                    instockCheck: {
                        $filter: {
                            input: '$instock', as: 'each', cond: {
                                $and: [{ $gt: [{ $toInt: '$$each.qty' }, 2] },
                                { $eq: ['$$each.warehouse', 'A'] }]
                            }
                        }
                    }
                }
            }, { $match: { instockCheck: { $gt: [] } } }, { $project: { instockCheck: 0, _id: 0 } }],
        cursor: { batchSize: 200 }
   });

测试： MongoDB-Playground