Grup kompas mongodb dengan beberapa kolom

Question

Grup MongoDB berdasarkan banyak bidang digunakan untuk mengelompokkan nilai berdasarkan banyak bidang menggunakan berbagai metodologi

Table of Contents Show

Operator $group di MongoDB
Pipa Agregasi
Alur Pemrosesan
Contoh $group Operator di MongoDB
$group_ pada Banyak Kunci di MongoDB
$group pada Beberapa Kunci Dengan db.invoice.aggregate([ { $group: { _id: { inv_date: "$inv_date", item: "$item" }, totalCost: { $sum: { $multiply: [ "$rate", "$qty" ] } }, avgQty: { $avg: "$qty" }, count: { $sum: 1 } } } ]) 9 di MongoDB
$group_ Nilai Berbeda di MongoDB
Bagaimana cara mengelompokkan beberapa nilai dalam MongoDB?
Bisakah kita melakukan pengelompokan di MongoDB?
Apa itu $$ root di MongoDB?
Bagaimana cara menggunakan hitungan dalam grup di MongoDB?

Salah satu cara paling efisien untuk mengelompokkan berbagai bidang yang ada di dalam dokumen MongoDB adalah dengan menggunakan operator $group, yang membantu dalam melakukan beberapa fungsi agregasi lainnya juga pada data yang dikelompokkan

Artikel ini akan membahas berbagai cara menggunakan operator di MongoDB untuk mengelompokkan nilai berdasarkan beberapa bidang di dalam dokumen. Ini juga akan melihat daftar operator yang digunakan bersama dengan agregasi dan bagaimana Anda dapat mengimplementasikannya dengan bantuan contoh

Operator $group di MongoDB

Input dan output dari operator $group MongoDB untuk beberapa bidang agregasi tidak lebih dari catatan tertulis dari database. Ia menerima satu dokumen dan mengembalikan satu atau lebih dokumen

Saat mengelompokkan berbagai bidang, Anda dapat menggunakan berbagai operator, yang dijelaskan di bawah ini

$first – hanya mengekstrak dokumen pertama dari sekelompok dokumen, biasanya digunakan saat menyortir

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

0 – menyisipkan nilai baru dari suatu bidang di dalam bidang yang dihasilkan

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

1 - masukkan nilai baru dari suatu bidang di dalam bidang yang dihasilkan pada akhirnya

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

2 – membantu menambahkan nilai baru ke nilai array yang ada tanpa terjadi duplikasi

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

3 – Operator ini membantu menemukan dan mengembalikan bilangan bulat terkecil atau nilai terkecil dari nilai bilangan bulat yang disediakan dan diteruskan

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

4 – menghitung nilai rata-rata dari semua nilai numerik yang ditentukan di antara bidang

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

5 – membantu menemukan dan mengembalikan nilai bilangan bulat paling signifikan atau nilai terbesar dari nilai bilangan bulat yang disediakan dan diteruskan

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

6 – Ini akan menghitung jumlah dari semua nilai numerik yang ditentukan

Pipa Agregasi

Saat mode

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

_7 diatur ke

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

8, cara lain untuk mengelompokkan bidang di MongoDB adalah dengan menggunakan saluran pipa. Menggunakan fungsi tabung polimer, Anda dapat memfilter dokumen yang memenuhi kriteria pipa agregasi

Operator tahapan ditentukan untuk setiap level pipa agregasi. Operator tahap secara internal dapat menggunakan operator ekspresi untuk memiliki jeda baris sebelum setiap tahap tingkat atau bahkan menghitung rata-rata atau menjumlahkan atau menggabungkan nilai tertentu

Keluaran pipa agregasi dianggap sebagai keluaran akhir yang akan dikembalikan, dan bahkan dapat disimpan dalam koleksi jika diperlukan

Alur Pemrosesan

Cara lain untuk mengelompokkan beberapa bidang adalah dengan menggunakan alur pemrosesan. Anda dapat menggunakan berbagai saluran untuk memproses data secara bersamaan dengan menggunakan fungsi

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

9

Fungsi

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

9 melakukan agregasi secara internal dan memberikan dukungan untuk beberapa operasi yang akan digunakan

Fungsi ________0______9 dapat digunakan secara efektif dengan urutan irisan tanpa menyebabkan hilangnya data. Fungsi

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

_9 mengembalikan data yang disimpan dalam memori sebagai kursor, yang dapat digunakan langsung sebagai

db.invoice.aggregate([
  {
    $group: {
      _id: {
        inv_date: "$inv_date",
        item: "$item"
      },
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

3

Contoh $group Operator di MongoDB

Anda dapat menggunakan koleksi berikut untuk artikel ini

db={
  "invoice": [
    {
      "_id": 1,
      "item": "apple",
      "qty": 20,
      "rate": 10,
      "inv_date": "02/02/2020"
    },
    {
      "_id": 2,
      "item": "orange",
      "qty": 15,
      "rate": 8,
      "inv_date": "05/12/2020"
    },
    {
      "_id": 3,
      "item": "mango",
      "qty": 25,
      "rate": 8,
      "inv_date": "07/02/2020"
    },
    {
      "_id": 4,
      "item": "apple",
      "qty": 20,
      "rate": 10,
      "inv_date": "02/02/2020"
    },
    {
      "_id": 5,
      "item": "mango",
      "qty": 10,
      "rate": 8,
      "inv_date": "05/12/2020"
    },
    {
      "_id": 6,
      "item": "apple",
      "qty": 30,
      "rate": 10,
      "inv_date": "13/04/2020"
    },
    {
      "_id": 7,
      "item": "orange",
      "qty": 15,
      "rate": 8,
      "inv_date": "05/12/2020"
    },
    {
      "_id": null,
      "item": "banana",
      "qty": 10,
      "rate": 20,
      "inv_date": "17/12/2020"
    },

  ]
}

Contoh berikut dikelompokkan berdasarkan bidang tanggal faktur dan menampilkan total biaya, jumlah rata-rata, dan jumlah faktur pada tanggal yang sama

db.invoice.aggregate([
  {
    $group: {
      _id: "$inv_date",
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

Hasilnya menunjukkan bahwa dokumen field invoice date telah dikelompokkan dan menunjukkan total biaya, average quantity, dan berapa banyak invoice yang dibuat untuk tanggal tersebut.

Group values

$group_ pada Banyak Kunci di MongoDB

Contoh berikut mengelompokkan menurut tanggal faktur, lalu menurut kolom item dan menampilkan total biaya, jumlah rata-rata, dan jumlah faktur pada tanggal yang sama

db.invoice.aggregate([
  {
    $group: {
      _id: {
        inv_date: "$inv_date",
        item: "$item"
      },
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

Hasil di bawah ini menunjukkan bahwa dokumen untuk tanggal invoice

db.invoice.aggregate([
  {
    $group: {
      _id: {
        inv_date: "$inv_date",
        item: "$item"
      },
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

6 dan

db.invoice.aggregate([
  {
    $group: {
      _id: {
        inv_date: "$inv_date",
        item: "$item"
      },
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

7 memiliki item yang sama;

Group values 1

$group pada Beberapa Kunci Dengan db.invoice.aggregate([ { $group: { _id: { inv_date: "$inv_date", item: "$item" }, totalCost: { $sum: { $multiply: [ "$rate", "$qty" ] } }, avgQty: { $avg: "$qty" }, count: { $sum: 1 } } } ]) 9 di MongoDB

Contoh berikut mengelompokkan berdasarkan tanggal faktur dan kemudian berdasarkan kolom item dan menampilkan total biaya, jumlah rata-rata, dan jumlah faktur pada tanggal yang sama untuk dokumen yang tanggal fakturnya adalah

db.invoice.aggregate([
  {
    $group: {
      _id: {
        inv_date: "$inv_date",
        item: "$item"
      },
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

6

db.invoice.aggregate([
  {
    $match: {
      inv_date: "05/12/2020"
    }
  },
  {
    $group: {
      _id: {
        inv_date: "$inv_date",
        item: "$item"
      },
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

Hasil di bawah ini menunjukkan bahwa dokumen untuk tanggal faktur

db.invoice.aggregate([
  {
    $group: {
      _id: {
        inv_date: "$inv_date",
        item: "$item"
      },
      totalCost: {
        $sum: {
          $multiply: [
            "$rate",
            "$qty"
          ]
        }
      },
      avgQty: {
        $avg: "$qty"
      },
      count: {
        $sum: 1
      }
    }
  }
])

6 memiliki tiga faktur, tetapi dengan kombinasi item yang sama telah membuat grup

Group values 2

$group_ Nilai Berbeda di MongoDB

Operasi agregasi berikut menggunakan tahap $group untuk mengelompokkan dokumen berdasarkan item untuk mengambil nilai item yang berbeda

db.invoice.aggregate([
  {
    $group: {
      _id: "$item"
    }
  }
])

Outputnya ditunjukkan pada tangkapan layar di bawah ini

Group values 3

Operasi agregasi berikut menggunakan tahap $group untuk mengelompokkan tanggal faktur dokumen berdasarkan item

db.invoice.aggregate([
  {
    $group: {
      _id: "$item",
      invoiceDate: {
        $push: "$inv_date"
      }
    }
  }
])

Screenshot di bawah ini adalah outputnya

Group values 4

Artikel ini mengajarkan Anda cara paling efisien untuk mengelompokkan beberapa bidang yang ada di dalam dokumen MongoDB dengan menggunakan operator $group

Itu juga membahas semua bentuk penggunaan operator di MongoDB dan daftar operator yang digunakan dengan agregasi, dan bagaimana Anda dapat mengimplementasikannya dengan bantuan contoh

Bagaimana cara mengelompokkan beberapa nilai dalam MongoDB?

Contoh 3. Grup BUCKET MongoDb oleh Berbagai Bidang . Agregasi ember adalah proses mengkategorikan dokumen ke dalam grup. Grup ini bertindak seperti ember. Setiap dokumen dibagi tergantung pada ekspresi tertentu. creating the bucket aggregation. Bucket aggregation is the process of categorizing the documents into groups. This group acts like buckets. Each document is divided depending on the specific expression.

Bisakah kita melakukan pengelompokan di MongoDB?

Pengantar grup MongoDB oleh. Grup MongoDB dengan digunakan untuk mengelompokkan data dari koleksi, kita dapat mencapai klausa grup demi menggunakan fungsi agregat dan metode grup di MongoDB .

Apa itu $$ root di MongoDB?

Variabel $$ROOT berisi dokumen sumber untuk grup . Jika Anda hanya ingin meneruskannya tanpa dimodifikasi, Anda dapat melakukan ini dengan $mendorong $$ROOT ke dalam output dari grup.