数据库操作中的子查询和导航查询

luobo · 2025 年9 月 8 日 14:00

在 C# 中，理解 MongoDB 的“子查询”和“导航查询”与 SQL 类型数据库的区别，关键在于认识到两种数据库底层数据模型和查询范式的根本差异。MongoDB 是一个文档型数据库，而 SQL 类数据库是关系型数据库。

MongoDB 本身并没有“子查询”（Subquery）或“导航查询”（Navigation Query）这些与 SQL 或 ORM（如Entity Framework）直接对应的概念。这些术语通常用来描述如何处理不同数据之间的关系。然而，MongoDB 通过其独特的机制实现了类似的功能。

MongoDB 中的子查询和导航查询

在 MongoDB 中，处理数据关联主要有以下几种方式，它们在某种程度上实现了类似 SQL 子查询或导航查询的效果：

1. 嵌入文档 (Embedding Documents) - 最常见的“导航”方式

这是MongoDB处理一对一或一对多关系最常见且推荐的方式。将相关联的文档直接嵌套在父文档内部。这样在查询父文档时，相关子文档也一并取出，无需额外的查询或“连接”操作。

示例：订单与订单项

一个订单文档中直接包含其所有订单项的列表。

// C# 定义文档模型
public class LineItem
{
    public string ProductId { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
}

public class Order
{
    [BsonId]
    [BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]
    public string Id { get; set; }
    public string CustomerId { get; set; }
    public DateTime OrderDate { get; set; }
    public List<LineItem> LineItems { get; set; } // 嵌入的订单项
    public decimal TotalAmount { get; set; }
}

// C# 查询嵌入文档
var ordersCollection = database.GetCollection<Order>("orders");

// 查询所有包含特定产品 "ProductA" 的订单
var ordersWithProductA = ordersCollection.Find(o => 
    o.LineItems.Any(li => li.ProductName == "ProductA")
).ToList();

// 查询订单总金额大于 100 并且包含特定产品 "ProductB" 的订单
var complexOrderQuery = ordersCollection.Find(o => 
    o.TotalAmount > 100 && 
    o.LineItems.Any(li => li.ProductName == "ProductB")
).ToList();

// 导航到订单项：一旦获取了订单，可以直接访问其 LineItems 属性
foreach (var order in ordersWithProductA)
{
    Console.WriteLine($"Order ID: {order.Id}, Customer ID: {order.CustomerId}");
    foreach (var item in order.LineItems)
    {
        Console.WriteLine($"  - Product: {item.ProductName}, Quantity: {item.Quantity}");
    }
}

特点：

性能高： 一次查询即可获取所有相关数据，减少了数据库往返次数。
原子性： 父文档和嵌入文档作为一个整体进行操作。
查询简单： 直接通过点符号访问嵌入字段。

2. 文档引用 (Document Referencing / Manual Linking) - 模拟“连接”

当嵌入文档不合适时（例如，一对多关系中的“多”方非常大，或者需要多对多关系），MongoDB允许你存储一个文档的 _id 在另一个文档中，从而在应用程序层面建立引用。这类似于SQL的外键，但MongoDB不会自动强制引用完整性。

示例：订单与客户

订单文档中只存储客户的 _id。

// C# 定义文档模型
public class Customer
{
    [BsonId]
    [BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]
    public string Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

public class OrderRef
{
    [BsonId]
    [BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]
    public string Id { get; set; }
    [BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]
    public string CustomerId { get; set; } // 引用 Customer 的 _id
    public DateTime OrderDate { get; set; }
    public decimal TotalAmount { get; set; }
    // ... 其他订单信息
}

// C# 模拟“子查询”或“导航查询”：需要两次查询
var ordersCollection = database.GetCollection<OrderRef>("orders");
var customersCollection = database.GetCollection<Customer>("customers");

// 步骤 1: 查询特定客户的订单（类似SQL的WHERE id IN (SELECT id FROM...)）
var customer = customersCollection.Find(c => c.Name == "Alice Smith").FirstOrDefault();
if (customer != null)
{
    var aliceOrders = ordersCollection.Find(o => o.CustomerId == customer.Id).ToList();
    Console.WriteLine($"Orders for Alice Smith ({customer.Id}):");
    foreach (var order in aliceOrders)
    {
        Console.WriteLine($"  - Order ID: {order.Id}, Total: {order.TotalAmount}");
    }
}

// 步骤 2: 查询订单，然后获取其关联的客户信息（类似SQL的JOIN或ORM的Include）
var recentOrders = ordersCollection.Find(o => o.OrderDate >= DateTime.Today.AddDays(-7)).ToList();

foreach (var order in recentOrders)
{
    // 这里需要再次查询客户集合，这就是“手动导航”
    var relatedCustomer = customersCollection.Find(c => c.Id == order.CustomerId).FirstOrDefault();
    if (relatedCustomer != null)
    {
        Console.WriteLine($"Order ID: {order.Id}, Customer Name: {relatedCustomer.Name}, Total: {order.TotalAmount}");
    }
}

特点：

数据规范化： 减少数据冗余。
更新灵活： 独立更新被引用文档。
查询复杂： 默认需要多次查询才能获取完整关联数据，或使用 $lookup。

3. `$lookup` (聚合管道操作) - 模拟“左外连接”

MongoDB的聚合管道提供了一个 $lookup 操作符，它可以在服务器端执行类似SQL的“左外连接”（Left Outer Join），将一个集合的文档与另一个集合的文档连接起来。这通常用于当你确实需要在服务器端连接数据，而不是在客户端执行多次查询时。

示例：使用 $lookup 连接订单和客户

// C# 使用 $lookup 聚合管道
var ordersCollection = database.GetCollection<OrderRef>("orders");

// 定义一个匿名类型来接收聚合结果，包含订单和关联的客户
// 注意：实际的 $lookup 结果会将关联文档放入一个数组。
// 为了简化示例，我们假设每个 OrderRef 只对应一个 Customer。
// 实际应用中可能需要更复杂的映射或使用 BsonDocument。
public class OrderWithCustomer
{
    public OrderRef Order { get; set; }
    public List<Customer> Customer { get; set; } // $lookup 结果会放入一个数组
}

var result = ordersCollection.Aggregate()
    .Lookup<OrderRef, Customer, OrderWithCustomer>(
        foreignCollectionName: "customers", // 外部集合的名称
        localField: o => o.CustomerId,       // orders 集合中用于连接的字段
        foreignField: c => c.Id,             // customers 集合中用于连接的字段
        @as: oc => oc.Customer             // 结果中存储连接文档的字段名（会是一个数组）
    )
    .Match(oc => oc.Order.TotalAmount > 50) // 可以在连接后对 Order 字段进行过滤
    .ToList();

foreach (var item in result)
{
    // 通常一个订单只有一个客户，所以取第一个
    var customer = item.Customer.FirstOrDefault(); 
    if (customer != null)
    {
        Console.WriteLine($"Order ID: {item.Order.Id}, Customer Name: {customer.Name}, Total: {item.Order.TotalAmount}");
    }
}

特点：

服务器端连接： 避免了客户端多次查询的开销。
更接近SQL Join： 适用于需要将相关数据组合在一起的复杂报告或分析。
性能考虑： $lookup 可能会比较耗费资源，尤其是在处理大量数据时。应谨慎使用，通常优先考虑嵌入文档。

和 SQL 类型数据库的区别总结

特性	MongoDB (文档型)	SQL 类型数据库 (关系型)
数据模型	文档型 (Document-Oriented)：数据存储在JSON或BSON文档中，天然支持嵌套结构。	关系型 (Relational)：数据存储在严格模式的表格中，通过行和列组织。
关联方式	1. 嵌入 (Embedding)：将相关数据直接嵌套在文档内。 2. 引用 (Referencing)：存储另一文档的 `_id` 进行逻辑关联。 3. `$lookup` (Aggregation)：在聚合管道中模拟左外连接。	外键 (Foreign Keys) 和 JOIN 操作：通过预定义的关系和JOIN语句连接不同表中的数据。
“子查询”概念	无直接概念：通过对嵌入数组的查询、链式客户端查询或 `$lookup` 模拟。	核心概念：一个查询嵌套在另一个查询内部，用于过滤、计算或作为派生表。
“导航查询”概念	无直接概念：在C#中，对于嵌入文档，直接访问属性即可；对于引用，需要手动进行第二次查询，或使用 `$lookup`。	ORM核心功能 (如Entity Framework)：基于模型中定义的关系（外键），ORM自动生成JOIN语句来加载相关数据。`Include()` 方法是典型例子。
查询执行	对于嵌入文档，单次查询获取所有数据。对于引用，通常需要多次查询（客户端）或聚合管道（服务器端）。	通常通过单个SQL语句（包含JOINs或子查询）获取所有相关数据。
数据一致性	最终一致性：无ACID事务支持（直到MongoDB 4.0引入多文档事务，但仍然有其局限性）。	强一致性 (ACID)：严格的数据完整性和事务支持，确保数据的一致性。
架构灵活性	无模式 (Schemaless)：文档结构可以灵活变化，无需预定义。	严格模式 (Schema-on-Write)：表结构必须预先定义，修改成本较高。
性能考量	读取性能：嵌入文档在读取时性能优异。写入性能：相对较高，尤其是对独立文档。连接性能：`$lookup` 相对昂贵。	读取性能：JOINs在优化得当（索引）的情况下性能良好。写入性能：受事务和约束影响可能略低。连接性能：成熟的查询优化器能高效处理JOINs。

总结来说：

SQL数据库 的“子查询”和“导航查询”（尤其通过ORM）是其关系模型的自然产物。它们依赖于预定义的关系和强大的JOIN操作，通常在服务器端一次性完成数据关联和检索。
MongoDB 由于其文档型和无模式的特性，没有直接的“子查询”或“导航查询”概念。它通过嵌入文档来实现数据的一体化存储和检索（最推荐），通过引用和客户端多查询来实现松散耦合的关联，或通过聚合管道的 $lookup 操作在服务器端模拟JOIN行为。

在C#中与MongoDB交互时，你需要根据你的数据模型和业务需求，选择最合适的关联方式来模拟SQL中的“子查询”和“导航查询”行为。优先考虑嵌入文档以获得最佳性能，当嵌入不适用时，再考虑引用和 $lookup。

数据库操作中的子查询和导航查询

MongoDB 中的子查询和导航查询

1. 嵌入文档 (Embedding Documents) - 最常见的“导航”方式

2. 文档引用 (Document Referencing / Manual Linking) - 模拟“连接”

3. $lookup (聚合管道操作) - 模拟“左外连接”

和 SQL 类型数据库的区别总结

3. `$lookup` (聚合管道操作) - 模拟“左外连接”