Giới hạn đường ống mongodb

Trong các bản phát hành MongoDB hiện đại, bạn có thể buộc điều này với

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
6 chỉ bên ngoài kết quả tổng hợp cơ bản. Đối với kết quả "lớn", thay vào đó, hãy chạy truy vấn bài hát song cho từng nhóm (danh sách diễn biến ở cuối câu trả lời) hoặc đợi máy chủ-9377 để giải quyết một mảng

Nội dung chính Hiển thị

  • Tóm tắt TLDR
  • MongoDB 3. 6 Xem trước
  • Nội dung gốc
  • Diễn biến mã
  • Chúng ta có thể sử dụng nhiều nhóm trong MongoDB không?
  • Làm cách nào để nhóm nhiều giá trị trong MongoDB?
  • Cái nào nhanh hơn trong việc tìm kiếm và tổng hợp trong MongoDB?
  • Phương pháp tổng hợp nào được ưa thích để sử dụng bởi MongoDB?

db.books.aggregate([
    { "$group": {
        "_id": {
            "addr": "$addr",
            "book": "$book"
        },
        "bookCount": { "$sum": 1 }
    }},
    { "$group": {
        "_id": "$_id.addr",
        "books": { 
            "$push": { 
                "book": "$_id.book",
                "count": "$bookCount"
            },
        },
        "count": { "$sum": "$bookCount" }
    }},
    { "$sort": { "count": -1 } },
    { "$limit": 2 },
    { "$project": {
        "books": { "$slice": [ "$books", 2 ] },
        "count": 1
    }}
])

MongoDB 3. 6 Xem trước

Vẫn chưa giải quyết được Server-9377, nhưng trong bản hành động này, ____99 cho phép tùy chọn "không tương thích" mới truy cập biểu thức

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
0 làm các đối số thay vì các tùy chọn
db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
1 và
db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
2. Điều này sau đó cho phép "tự tham gia" với một biểu thức đường ống khác, trong đó chúng ta có thể áp dụng ______03 để trả về kết quả "Top-N".
db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])

Sự bổ sung khác ở đây tất nhiên là khả năng suy biến thông qua nội năng

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
4 bằng cách sử dụng
db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
5 để chọn các mục phù hợp trong "tham gia", nhưng tiền đề chung là "đường ống trong đường ống" trong đó nội dung bên trong có thể được lọc bởi các trận đấu từ cha mẹ. Vì cả hai đều là "đường ống", chúng tôi có thể ______03 mỗi kết quả riêng biệt

Đây sẽ là tùy chọn tốt nhất tiếp theo để chạy các bài hát truy vấn bài hát và thực sự sẽ tốt hơn nếu

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
5 được phép và có thể sử dụng một mục trong quá trình xử lý "đường dẫn phụ". Vì vậy, điều đó không sử dụng "giới hạn cho
db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
7" vì vấn đề được tham khảo yêu cầu, nó thực sự cung cấp một cái gì đó sẽ hoạt động tốt hơn

Nội dung gốc

You as was gone to problems "N" hàng đầu. Dù sao đi nữa, vấn đề của bạn sẽ dễ dàng được giải quyết mặc dù không giới hạn chính xác mà bạn yêu cầu

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
0

Bây giờ điều đó sẽ cho bạn một kết quả như thế này

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
1

Vì vậy, điều này khác với những gì bạn đang hỏi trong đó, trong khi chúng tôi nhận được kết quả hàng đầu cho các giá trị địa chỉ, lựa chọn "sách" cơ bản không giới hạn ở một lượng kết quả cần thiết

Điều này hóa ra rất khó thực hiện, nhưng nó có thể được thực hiện mặc dù mức độ phức tạp chỉ tăng theo số lượng vật phẩm bạn cần để phù hợp. Để giữ cho nó đơn giản, chúng ta có thể duy trì điều này ở mức 2 trận đấu nhiều nhất

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
2

Vì vậy, điều đó thực sự sẽ cung cấp cho bạn 2 "cuốn sách" hàng đầu từ hai mục "địa chỉ" hàng đầu

Nhưng đối với tiền của tôi, hãy quay lại với hình thức đầu tiên và sau đó chỉ đơn giản là "cắt" các phần tử của mảng được trả lại để lấy các phần tử đầu tiên "n"


Diễn biến mã

Diễn biến mã phù hợp để sử dụng với các phiên bản LTS hiện có của NodeJS từ bản phát hành V8. x và V10. x. Điều đó chủ yếu là cho cú pháp

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
9, nhưng không có gì thực sự trong dòng chảy chung có bất kỳ hạn chế nào như vậy và điều chỉnh với rất ít sự thay đổi đối với những lời hứa đơn giản hoặc thậm chí chí quay lại thực hiện gọi lại đơn giản

mục lục. js

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
4

sách. json

db.books.aggregate([
  { "$group": {
    "_id": "$addr",
    "count": { "$sum": 1 }
  }},
  { "$sort": { "count": -1 } },
  { "$limit": 2 },
  { "$lookup": {
    "from": "books",
    "let": {
      "addr": "$_id"
    },
    "pipeline": [
      { "$match": { 
        "$expr": { "$eq": [ "$addr", "$$addr"] }
      }},
      { "$group": {
        "_id": "$book",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1  } },
      { "$limit": 2 }
    ],
    "as": "books"
  }}
])
5

Chúng ta có thể sử dụng nhiều nhóm trong MongoDB không?

Chúng tôi có thể nhóm theo đơn cũng như nhiều trường từ bộ sưu tập. Chúng tôi cũng có thể thực hiện tất cả các hoạt động $AVG, $Sum, $Max, $Min, $Push, $cuối cùng, $đầu tiên, v. v. with the group of MongoDB. . Chúng tôi cũng có thể thực hiện tất cả các thao tác này $avg, $sum, $max, $min, $push, $last, $first, v.v. với nhóm theo trong MongoDB.

Làm cách nào để nhóm nhiều giá trị trong MongoDB?

Ví dụ 3. Nhóm xô MongoDB theo nhiều trường Điều kiện này được thực hiện bằng cách tạo tập hợp xô. Xox file is too a partition the document into the group. Nhóm này hoạt động như xô. Mỗi tài liệu được chia tùy thuộc vào biểu thức cụ thể. tạo tập hợp nhóm . Bucket tổng hợp là quá trình phân loại các tài liệu thành các nhóm. Nhóm này hoạt động như những cái xô. Mỗi văn bản được phân chia tùy theo cách diễn đạt cụ thể.

Cái nào nhanh hơn trong việc tìm kiếm và tổng hợp trong MongoDB?

Truy vấn tổng hợp mất ~ 80ms trong khi truy vấn tìm kiếm 0 hoặc 1ms. truy vấn tổng hợp mất ~80 mili giây trong khi truy vấn tìm mất 0 hoặc 1 mili giây .

Phương pháp tổng hợp nào được ưa thích để sử dụng bởi MongoDB?

Đường ống cung cấp hiệu quả tổng hợp dữ liệu bằng cách sử dụng các hoạt động gốc trong MongoDB và là phương pháp ưa thích để tổng hợp dữ liệu trong MongoDB. Các đường ống tổng hợp có thể hoạt động trên một bộ sưu tập Sharded. Đường ống tổng hợp có thể sử dụng các chỉ mục để cải thiện hiệu suất của nó trong một số giai đoạn của nó