ค่ากลุ่ม mongodb ตามหลายฟิลด์

111

ตัวอย่างเช่นฉันมีเอกสารเหล่านี้:

{
  "addr": "address1",
  "book": "book1"
},
{
  "addr": "address2",
  "book": "book1"
},
{
  "addr": "address1",
  "book": "book5"
},
{
  "addr": "address3",
  "book": "book9"
},
{
  "addr": "address2",
  "book": "book5"
},
{
  "addr": "address2",
  "book": "book1"
},
{
  "addr": "address1",
  "book": "book1"
},
{
  "addr": "address15",
  "book": "book1"
},
{
  "addr": "address9",
  "book": "book99"
},
{
  "addr": "address90",
  "book": "book33"
},
{
  "addr": "address4",
  "book": "book3"
},
{
  "addr": "address5",
  "book": "book1"
},
{
  "addr": "address77",
  "book": "book11"
},
{
  "addr": "address1",
  "book": "book1"
}

และอื่น ๆ


ฉันจะส่งคำขอได้อย่างไรซึ่งจะอธิบายถึงที่อยู่บนสุดและหนังสือ M อันดับต้น ๆ ต่อที่อยู่

ตัวอย่างผลลัพธ์ที่คาดหวัง:

address1 | book_1: 5
| book_2: 10
| book_3: 50
| ทั้งหมด: 65
______________________
address2 | book_1: 10
| book_2: 10
| ...
| book_M: 10
| ทั้งหมด: M * 10
...
______________________
addressN | book_1: 20
| book_2: 20
| ...
| book_M: 20
| รวม: M * 20

mongodb  aggregation-framework 
— เร่าร้อน
แหล่งที่มา

คำตอบ:

213

สรุป TLDR

ในการเผยแพร่ MongoDB สมัยใหม่คุณสามารถบังคับสิ่งนี้ได้โดย$sliceไม่ต้องใช้ผลการรวมพื้นฐาน สำหรับผลลัพธ์ "ใหญ่" ให้เรียกใช้แบบสอบถามคู่ขนานแทนสำหรับการจัดกลุ่มแต่ละกลุ่ม (รายการสาธิตอยู่ที่ท้ายคำตอบ) หรือรอให้SERVER-9377แก้ไขซึ่งจะทำให้ "จำกัด " จำนวนรายการที่$pushจะ อาร์เรย์

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 ดูตัวอย่าง

ยังไม่สามารถแก้ไขSERVER-9377ได้ แต่ในรุ่นนี้$lookupอนุญาตให้มีตัวเลือก "ไม่สัมพันธ์" ใหม่ซึ่งใช้"pipeline"นิพจน์เป็นอาร์กิวเมนต์แทน"localFields"และ"foreignFields"ตัวเลือก จากนั้นจะอนุญาตให้ "เข้าร่วมด้วยตนเอง" ด้วยนิพจน์ไปป์ไลน์อื่นซึ่งเราสามารถใช้$limitเพื่อส่งคืนผลลัพธ์ "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"
  }}
])

ส่วนเพิ่มเติมอื่น ๆ ในที่นี้คือความสามารถในการแก้ไขตัวแปรโดย$exprใช้$matchเพื่อเลือกรายการที่ตรงกันใน "เข้าร่วม" แต่หลักฐานทั่วไปคือ "ไปป์ไลน์ภายในไปป์ไลน์" ซึ่งเนื้อหาภายในสามารถกรองได้โดยการจับคู่จากพาเรนต์ . เนื่องจากทั้งสองเป็น "ท่อ" ในตัวเราจึงสามารถ$limitแยกผลลัพธ์

นี่จะเป็นตัวเลือกถัดไปที่ดีที่สุดในการเรียกใช้การสืบค้นแบบขนานและจะดีกว่าถ้าหาก$matchได้รับอนุญาตและสามารถใช้ดัชนีในการประมวลผล "ท่อย่อย" ได้ ดังนั้นสิ่งที่ไม่ใช้ "ขีด จำกัด$push" ตามที่ปัญหาที่อ้างถึงถามมันให้สิ่งที่ควรจะทำงานได้ดีกว่า

เนื้อหาต้นฉบับ

ดูเหมือนคุณจะสะดุดกับปัญหา "N" อันดับต้น ๆ วิธีแก้ปัญหาของคุณค่อนข้างง่ายแม้ว่าจะไม่ตรงตามข้อ จำกัด ที่คุณขอ

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 }
])

ตอนนี้จะให้ผลลัพธ์ดังนี้:

{
    "result" : [
            {
                    "_id" : "address1",
                    "books" : [
                            {
                                    "book" : "book4",
                                    "count" : 1
                            },
                            {
                                    "book" : "book5",
                                    "count" : 1
                            },
                            {
                                    "book" : "book1",
                                    "count" : 3
                            }
                    ],
                    "count" : 5
            },
            {
                    "_id" : "address2",
                    "books" : [
                            {
                                    "book" : "book5",
                                    "count" : 1
                            },
                            {
                                    "book" : "book1",
                                    "count" : 2
                            }
                    ],
                    "count" : 3
            }
    ],
    "ok" : 1
}

ดังนั้นสิ่งนี้จึงแตกต่างจากสิ่งที่คุณถามในขณะที่เราได้รับผลลัพธ์อันดับต้น ๆ สำหรับค่าที่อยู่การเลือก "หนังสือ" ที่อยู่ภายใต้นั้นไม่ได้ จำกัด อยู่เพียงผลลัพธ์ตามจำนวนที่ต้องการเท่านั้น

สิ่งนี้กลายเป็นเรื่องยากที่จะทำ แต่สามารถทำได้แม้ว่าความซับซ้อนจะเพิ่มขึ้นตามจำนวนรายการที่คุณต้องจับคู่ เพื่อให้ง่ายเราสามารถรักษาสิ่งนี้ไว้ได้สูงสุด 2 รายการ:

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 },
    { "$unwind": "$books" },
    { "$sort": { "count": 1, "books.count": -1 } },
    { "$group": {
        "_id": "$_id",
        "books": { "$push": "$books" },
        "count": { "$first": "$count" }
    }},
    { "$project": {
        "_id": {
            "_id": "$_id",
            "books": "$books",
            "count": "$count"
        },
        "newBooks": "$books"
    }},
    { "$unwind": "$newBooks" },
    { "$group": {
      "_id": "$_id",
      "num1": { "$first": "$newBooks" }
    }},
    { "$project": {
        "_id": "$_id",
        "newBooks": "$_id.books",
        "num1": 1
    }},
    { "$unwind": "$newBooks" },
    { "$project": {
        "_id": "$_id",
        "num1": 1,
        "newBooks": 1,
        "seen": { "$eq": [
            "$num1",
            "$newBooks"
        ]}
    }},
    { "$match": { "seen": false } },
    { "$group":{
        "_id": "$_id._id",
        "num1": { "$first": "$num1" },
        "num2": { "$first": "$newBooks" },
        "count": { "$first": "$_id.count" }
    }},
    { "$project": {
        "num1": 1,
        "num2": 1,
        "count": 1,
        "type": { "$cond": [ 1, [true,false],0 ] }
    }},
    { "$unwind": "$type" },
    { "$project": {
        "books": { "$cond": [
            "$type",
            "$num1",
            "$num2"
        ]},
        "count": 1
    }},
    { "$group": {
        "_id": "$_id",
        "count": { "$first": "$count" },
        "books": { "$push": "$books" }
    }},
    { "$sort": { "count": -1 } }
])

นั่นจะทำให้คุณได้รับ "หนังสือ" 2 อันดับแรกจากรายการ "ที่อยู่" สองอันดับแรก

แต่สำหรับเงินของฉันให้อยู่กับรูปแบบแรกจากนั้นเพียงแค่ "แบ่ง" องค์ประกอบของอาร์เรย์ที่ส่งกลับมาเพื่อรับองค์ประกอบ "N" แรก

รหัสสาธิต

รหัสสาธิตนี้เหมาะสำหรับการใช้งานกับ NodeJS เวอร์ชัน LTS ปัจจุบันตั้งแต่รุ่น v8.x และ v10.x นั่นเป็นส่วนใหญ่สำหรับasync/awaitไวยากรณ์ แต่ไม่มีอะไรในโฟลว์ทั่วไปที่มีข้อ จำกัด ดังกล่าวและปรับเปลี่ยนเพียงเล็กน้อยกับสัญญาธรรมดาหรือแม้กระทั่งกลับไปใช้การเรียกกลับธรรมดา

index.js

const { MongoClient } = require('mongodb');
const fs = require('mz/fs');

const uri = 'mongodb://localhost:27017';

const log = data => console.log(JSON.stringify(data, undefined, 2));

(async function() {

  try {
    const client = await MongoClient.connect(uri);

    const db = client.db('bookDemo');
    const books = db.collection('books');

    let { version } = await db.command({ buildInfo: 1 });
    version = parseFloat(version.match(new RegExp(/(?:(?!-).)*/))[0]);

    // Clear and load books
    await books.deleteMany({});

    await books.insertMany(
      (await fs.readFile('books.json'))
        .toString()
        .replace(/\n$/,"")
        .split("\n")
        .map(JSON.parse)
    );

    if ( version >= 3.6 ) {

    // Non-correlated pipeline with limits
      let result = await books.aggregate([
        { "$group": {
          "_id": "$addr",
          "count": { "$sum": 1 }
        }},
        { "$sort": { "count": -1 } },
        { "$limit": 2 },
        { "$lookup": {
          "from": "books",
          "as": "books",
          "let": { "addr": "$_id" },
          "pipeline": [
            { "$match": {
              "$expr": { "$eq": [ "$addr", "$$addr" ] }
            }},
            { "$group": {
              "_id": "$book",
              "count": { "$sum": 1 },
            }},
            { "$sort": { "count": -1 } },
            { "$limit": 2 }
          ]
        }}
      ]).toArray();

      log({ result });
    }

    // Serial result procesing with parallel fetch

    // First get top addr items
    let topaddr = await books.aggregate([
      { "$group": {
        "_id": "$addr",
        "count": { "$sum": 1 }
      }},
      { "$sort": { "count": -1 } },
      { "$limit": 2 }
    ]).toArray();

    // Run parallel top books for each addr
    let topbooks = await Promise.all(
      topaddr.map(({ _id: addr }) =>
        books.aggregate([
          { "$match": { addr } },
          { "$group": {
            "_id": "$book",
            "count": { "$sum": 1 }
          }},
          { "$sort": { "count": -1 } },
          { "$limit": 2 }
        ]).toArray()
      )
    );

    // Merge output
    topaddr = topaddr.map((d,i) => ({ ...d, books: topbooks[i] }));
    log({ topaddr });

    client.close();

  } catch(e) {
    console.error(e)
  } finally {
    process.exit()
  }

})()

books.json

{ "addr": "address1",  "book": "book1"  }
{ "addr": "address2",  "book": "book1"  }
{ "addr": "address1",  "book": "book5"  }
{ "addr": "address3",  "book": "book9"  }
{ "addr": "address2",  "book": "book5"  }
{ "addr": "address2",  "book": "book1"  }
{ "addr": "address1",  "book": "book1"  }
{ "addr": "address15", "book": "book1"  }
{ "addr": "address9",  "book": "book99" }
{ "addr": "address90", "book": "book33" }
{ "addr": "address4",  "book": "book3"  }
{ "addr": "address5",  "book": "book1"  }
{ "addr": "address77", "book": "book11" }
{ "addr": "address1",  "book": "book1"  }
— นีลลุนน์
แหล่งที่มา
47

การใช้ฟังก์ชันการรวมดังต่อไปนี้: 

[
{$group: {_id : {book : '$book',address:'$addr'}, total:{$sum :1}}},
{$project : {book : '$_id.book', address : '$_id.address', total : '$total', _id : 0}}
]

มันจะให้ผลลัพธ์ดังต่อไปนี้: 

        {
            "total" : 1,
            "book" : "book33",
            "address" : "address90"
        }, 
        {
            "total" : 1,
            "book" : "book5",
            "address" : "address1"
        }, 
        {
            "total" : 1,
            "book" : "book99",
            "address" : "address9"
        }, 
        {
            "total" : 1,
            "book" : "book1",
            "address" : "address5"
        }, 
        {
            "total" : 1,
            "book" : "book5",
            "address" : "address2"
        }, 
        {
            "total" : 1,
            "book" : "book3",
            "address" : "address4"
        }, 
        {
            "total" : 1,
            "book" : "book11",
            "address" : "address77"
        }, 
        {
            "total" : 1,
            "book" : "book9",
            "address" : "address3"
        }, 
        {
            "total" : 1,
            "book" : "book1",
            "address" : "address15"
        }, 
        {
            "total" : 2,
            "book" : "book1",
            "address" : "address2"
        }, 
        {
            "total" : 3,
            "book" : "book1",
            "address" : "address1"
        }

ฉันไม่ค่อยได้รับรูปแบบผลลัพธ์ที่คุณคาดหวังดังนั้นอย่าลังเลที่จะแก้ไขสิ่งนี้เป็นรูปแบบที่คุณต้องการ

— Sikorski
แหล่งที่มา
1
ซึ่งช่วยแก้ปัญหาได้เพียงบางส่วนเท่านั้นและไม่ได้ทำ "ด้านบน" สำหรับการจัดกลุ่มสองกลุ่ม
— WiredPrairie
ยิ่งไปกว่านั้นในความคิดเห็นจาก @WiredPrairie ฉันไม่เห็นว่าสิ่งนี้แก้ปัญหาส่วนใดส่วนหนึ่งของคำถามที่นำเสนอได้อย่างไร "N ที่อยู่บนสุดและ N หนังสืออันดับต้น ๆ ต่อที่อยู่"
— Neil Lunn
กรุณาช่วยหากคุณสามารถทำได้สำหรับคำถามที่เกี่ยวข้องใน mongoDB - stackoverflow.com/questions/61067856/…
— newdeveloper
5

แบบสอบถามด้านล่างจะให้ผลลัพธ์เหมือนกับที่ระบุไว้ในคำตอบที่ต้องการ:

db.books.aggregate([
    {
        $group: {
            _id: { addresses: "$addr", books: "$book" },
            num: { $sum :1 }
        }
    },
    {
        $group: {
            _id: "$_id.addresses",
            bookCounts: { $push: { bookName: "$_id.books",count: "$num" } }
        }
    },
    {
        $project: {
            _id: 1,
            bookCounts:1,
            "totalBookAtAddress": {
                "$sum": "$bookCounts.count"
            }
        }
    }

])

คำตอบจะมีลักษณะดังนี้: 

/* 1 */
{
    "_id" : "address4",
    "bookCounts" : [
        {
            "bookName" : "book3",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 1
},

/* 2 */
{
    "_id" : "address90",
    "bookCounts" : [
        {
            "bookName" : "book33",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 1
},

/* 3 */
{
    "_id" : "address15",
    "bookCounts" : [
        {
            "bookName" : "book1",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 1
},

/* 4 */
{
    "_id" : "address3",
    "bookCounts" : [
        {
            "bookName" : "book9",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 1
},

/* 5 */
{
    "_id" : "address5",
    "bookCounts" : [
        {
            "bookName" : "book1",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 1
},

/* 6 */
{
    "_id" : "address1",
    "bookCounts" : [
        {
            "bookName" : "book1",
            "count" : 3
        },
        {
            "bookName" : "book5",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 4
},

/* 7 */
{
    "_id" : "address2",
    "bookCounts" : [
        {
            "bookName" : "book1",
            "count" : 2
        },
        {
            "bookName" : "book5",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 3
},

/* 8 */
{
    "_id" : "address77",
    "bookCounts" : [
        {
            "bookName" : "book11",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 1
},

/* 9 */
{
    "_id" : "address9",
    "bookCounts" : [
        {
            "bookName" : "book99",
            "count" : 1
        }
    ],
    "totalBookAtAddress" : 1
}
— Jitendra
แหล่งที่มา
ขอบคุณมาก bhai! นี่คือสิ่งที่ฉันกำลังมองหา ขอบคุณมาก!!
— Abhijeet Raj
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.