使用python快速上手MongoDB

一、python中查询MongoDB的方式

from pymongo import MongoClient

# 创建与数据库的连接
client = MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
collection = db["mycollection"]

find(): find()方法用于从集合中检索文档。它接受一个查询条件参数，并返回满足条件的所有文档。

# 查询年龄大于等于25的所有文档
query = {"age": {"$gte": 25}}
results = collection.find(query)
# 转为dataframe
df = pd.DataFrame(list(results))

findOne(): findOne()方法用于检索集合中满足条件的第一个文档。它与find()类似，但只返回一个文档。

# 查询第一个年龄大于等于25的文档
query = {"age": {"$gte": 25}}
result = collection.find_one(query)
# 转为dataframe
df = pd.DataFrame(list(results))

count_documents(): count_documents()方法用于计算满足条件的文档数量。

# 统计年龄大于等于25的文档数量
query = {"age": {"$gte": 25}}
count = collection.count_documents(query)

distinct(): distinct()方法用于获取指定字段的不同值列表。

# 获取所有不同的城市列表
distinct_cities = collection.distinct("city")

sort(): sort()方法用于对查询结果进行排序。

# 查询年龄大于等于25的文档，并按年龄降序排序
query = {"age": {"$gte": 25}}
results = collection.find(query).sort("age", -1)

limit(): limit()方法用于限制返回结果的数量。

# 查询前5个年龄大于等于25的文档
query = {"age": {"$gte": 25}}
results = collection.find(query).limit(5)

skip(): skip()方法用于跳过一定数量的文档，常与limit()一起使用以实现分页效果。

# 查询年龄大于等于25的文档，跳过前10个，返回接下来的5个
query = {"age": {"$gte": 25}}
results = collection.find(query).skip(10).limit(5)

二、操作符：

1、比较操作符：

$eq： 等于，匹配字段值与指定值相等的文档。

db.collection.find({ "age": { $eq: 25 } })

$ne： 不等于，匹配字段值与指定值不相等的文档。

db.collection.find({ "age": { $ne: 25 } })

$gt： 大于，匹配字段值大于指定值的文档。

db.collection.find({ "age": { $gt: 25 } })

$lt： 小于，匹配字段值小于指定值的文档。

db.collection.find({ "age": { $lt: 30 } })

$gte： 大于等于，匹配字段值大于等于指定值的文档。

db.collection.find({ "age": { $gte: 25 } })

$lte： 小于等于，匹配字段值小于等于指定值的文档。

db.collection.find({ "age": { $lte: 30 } })

2、逻辑操作符：

$and： 逻辑与，匹配同时满足多个条件的文档。

db.collection.find({ $and: [{ "age": { $gte: 25 } }, { "city": "New York" }] })

$or： 逻辑或，匹配满足任一条件的文档。

db.collection.find({ $or: [{ "age": { $gte: 25 } }, { "city": "London" }] })

$not： 逻辑非，匹配不满足指定条件的文档。

db.collection.find({ "age": { $not: { $lt: 25 } } })

3、数组操作符：

$in： 匹配字段值在指定值数组中的文档。

db.collection.find({ "age": { $in: [25, 30] } })

$nin： 匹配字段值不在指定值数组中的文档。

db.collection.find({ "age": { $nin: [25, 30] } })

$all： 匹配数组字段同时包含指定所有值的文档。

db.collection.find({ "tags": { $all: ["mongodb", "nosql"] } })

$size： 匹配数组字段长度与指定值相等的文档。

db.collection.find({ "tags": { $size: 3 } })

4、存在性操作符：

$exists： 检查字段是否存在。

db.collection.find({ "address": { $exists: true } })

三、复杂查询使用aggregate

aggregate 是 MongoDB 中用于执行数据聚合操作的强大方法。它可以用于处理大量数据、计算聚合指标和转换数据，通常用于复杂的数据分析和报表生成。
aggregate 方法使用一系列的聚合阶段（pipeline stages）来处理数据，每个阶段都执行一个特定的操作。以下是一些常见的聚合操作阶段及其用法：
$match 阶段：用于筛选文档，只传递满足指定条件的文档到下一个阶段。

db.collection.aggregate([
    { $match: { age: { $gte: 25 } } }
])

$group 阶段：将文档分组并执行聚合操作，例如计算总和、平均值等。

db.collection.aggregate([
    { $group: { _id: "$city", totalAge: { $sum: "$age" } } }
])

$project 阶段：用于投影文档中的指定字段，即选择需要的字段进行输出。

db.collection.aggregate([
    { $project: { name: 1, age: 1, _id: 0 } }
])

$sort 阶段：对文档进行排序。

db.collection.aggregate([
    { $sort: { age: -1 } }
])

$limit 阶段：限制输出文档的数量。

db.collection.aggregate([
    { $limit: 10 }
])

$skip 阶段：跳过指定数量的文档，用于实现分页效果。

db.collection.aggregate([
    { $skip: 10 }
])

$unwind 阶段：将数组字段展开，使每个数组元素成为一个独立的文档。

db.collection.aggregate([
    { $unwind: "$tags" }
])

$lookup 阶段：在多个集合之间执行左连接操作，以关联和合并数据。

db.orders.aggregate([
    {
        $lookup: {
            from: "products",
            localField: "product_id",
            foreignField: "_id",
            as: "product"
        }
    }
])

四、复杂查询的举例

eg1 自连接

情景： 一个包含员工信息的 MongoDB 集合，其中每个文档包含员工的 ID、姓名、上级（经理）的 ID 和所在部门的 ID。我们将执行一个聚合查询，以获取每个员工的姓名、所在部门的名称、以及他们的直接经理的姓名。

数据 假设我们有以下的员工集合（假设为 employees 集合）：

[
  { "_id": 1, "name": "Alice", "manager": 3, "department": "HR" },
  { "_id": 2, "name": "Bob", "manager": 3, "department": "IT" },
  { "_id": 3, "name": "Charlie", "manager": null, "department": "Management" },
  { "_id": 4, "name": "David", "manager": 2, "department": "IT" },
  { "_id": 5, "name": "Eve", "manager": 1, "department": "HR" }
]

下面是一个使用 aggregate 查询的示例，以获取每个员工的姓名、所在部门的名称以及他们的直接经理的姓名：

db.employees.aggregate([
  {
    $lookup: {
      from: "employees",
      localField: "manager",
      foreignField: "_id",
      as: "managerInfo"
    }
  },
  {
    $unwind: "$managerInfo"
  },
  {
    $project: {
      _id: 1,
      name: 1,
      department: 1,
      managerName: "$managerInfo.name"
    }
  }
])

在这个查询中：

使用 $lookup 阶段，我们将 employees 集合自连接，将 manager 字段与 _id 字段关联，从而获取每个员工的经理信息。
使用 $unwind 阶段展开 managerInfo 数组，以便后续投影操作可以访问经理的文档。
使用 $project 阶段，我们将只输出需要的字段，包括员工的姓名、部门和经理的姓名。

最终的查询结果将会类似于：

[
  { "_id": 1, "name": "Alice", "department": "HR", "managerName": "Charlie" },
  { "_id": 2, "name": "Bob", "department": "IT", "managerName": "Charlie" },
  { "_id": 3, "name": "Charlie", "department": "Management", "managerName": null },
  { "_id": 4, "name": "David", "department": "IT", "managerName": "Bob" },
  { "_id": 5, "name": "Eve", "department": "HR", "managerName": "Alice" }
]

eg2 连接其它集合

假设我们有两个数据库：db1 和 db2，每个数据库都有一个集合：orders 和 customers。我们希望从 orders 集合中检索订单信息，并外连接到 customers 集合以获取顾客的名称。

db.orders.aggregate([
  {
    $lookup: {
      from: "db2.customers",  // 在另一个数据库中的集合
      localField: "customer_id",
      foreignField: "_id",
      as: "customer_info"
    }
  },
  {
    $unwind: "$customer_info"
  },
  {
    $project: {
      _id: 1,
      order_number: 1,
      order_date: 1,
      customer_name: "$customer_info.name"
    }
  }
])