[mongodb] mongodb 그룹 값을 여러 필드로

Program / 글쓴이

예를 들어 다음 문서가 있습니다.

{
  "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"
}

등등.

상위 N 개 주소와 주소 당 상위 M 개의 도서를 설명하는 요청을 어떻게 할 수 있습니까?

예상 결과의 예 :

address1 | book_1 : 5
| book_2 : 10
| book_3 : 50
| 합계 : 65
______________________
주소 2 | book_1 : 10
| book_2 : 10
| …
| book_M : 10
| 합계 : M * 10
…
______________________
주소 N | book_1 : 20
| book_2 : 20
| …
| book_M : 20
| 합계 : M * 20

답변

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 개의 “주소”항목에서 상위 2 개의 “책”이 제공됩니다.

그러나 내 돈을 위해 첫 번째 형식을 유지 한 다음 반환되는 배열의 요소를 “슬라이스”하여 첫 번째 “N”요소를 가져옵니다.

데모 코드

데모 코드는 v8.x 및 v10.x 릴리스의 NodeJS의 현재 LTS 버전에 사용하기에 적합합니다. 그것은 대부분 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"  }

답변

아래와 같이 집계 함수 사용 : 

[
{$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"
        }

예상 한 결과 형식을 얻지 못 했으므로 원하는 형식으로 자유롭게 수정하십시오.

답변

아래 쿼리는 원하는 응답에 제공된 것과 정확히 동일한 결과를 제공합니다.

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
}

답변