Jumlah pencarian mongodb dengan kondisi

Kata pengantar. Baru mengenal saluran agregasi?

Pastikan juga untuk memahami pengindeksan dan implikasi kinerjanya sebelum meninjau contoh-contoh ini

$lookup memungkinkan Anda melakukan gabungan pada koleksi di database yang sama. $lookup berfungsi dengan mengembalikan dokumen dari koleksi "bergabung" sebagai sub-array dari koleksi asli

$lookup mendukung pencocokan kesetaraan dasar maupun sub-kueri yang tidak berkorelasi. Kami akan memberikan contoh dari setiap skenario

Contoh-contoh didasarkan pada data sampel ini

koleksi pos

{
    "title" : "my first post",
    "author" : "Jim",
    "likes" : 5
},
{
    "title" : "my second post",
    "author" : "Jim",
    "likes" : 2
},
{
    "title" : "hello world",
    "author" : "Joe",
    "likes" : 3
}

koleksi komentar

{
    "postTitle" : "my first post",
    "comment" : "great read",
    "likes" : 3
},
{
    "postTitle" : "my second post",
    "comment" : "good info",
    "likes" : 0
},
{
    "postTitle" : "my second post",
    "comment" : "i liked this post",
    "likes" : 12
},
{
    "postTitle" : "hello world",
    "comment" : "not my favorite",
    "likes" : 8
},
{
    "postTitle" : "my last post",
    "comment" : null,
    "likes" : 0
}
_

Perhatikan bagaimana kami memiliki dua koleksi posting dan komentar. Bidang postTitle di koleksi komentar sesuai dengan bidang judul di koleksi posting

Baik komentar maupun postingan memiliki suka

contoh $lookup. pertandingan kesetaraan

db.posts.aggregate([
    { $lookup:
        {
           from: "comments",
           localField: "title",
           foreignField: "postTitle",
           as: "comments"
        }
    }
])

Perhatikan bagaimana $lookup mengambil dokumen dengan bidang-bidang berikut

  • dari. koleksi yang ingin kita ikuti
  • bidanglokal. bidang yang ingin kami gabungkan dalam koleksi lokal (koleksi tempat kami menjalankan kueri)
  • foreignField. bidang yang ingin kita ikuti dalam koleksi asing (koleksi yang ingin kita gabungkan)
  • sebagai. nama array keluaran untuk hasil

Kueri ini mengembalikan yang berikut ini

{
    "title" : "my first post",
    "author" : "Jim",
    "likes" : 5,
    "comments" : [
        {
            "postTitle" : "my first post",
            "comment" : "great read",
            "likes" : 3
        }
    ]
},
{
    "title" : "my second post",
    "author" : "Jim",
    "likes" : 2,
    "comments" : [
        {
            "postTitle" : "my second post",
            "comment" : "good info",
            "likes" : 0
        },
        {
            "postTitle" : "my second post",
            "comment" : "i liked this post",
            "likes" : 12
        }
    ]
},
{
    "title" : "hello world",
    "author" : "Joe",
    "likes" : 3,
    "comments" : [
        {
            "postTitle" : "hello world",
            "comment" : "not my favorite",
            "likes" : 8
        }
    ]
}

Perhatikan bagaimana 3 dokumen asli dari kumpulan pos dikembalikan dengan kolom komentar tambahan

Untuk setiap kiriman, susunan komentar baru ini memiliki semua dokumen dari kumpulan komentar yang bidang postTitle cocok dengan bidang judul kiriman

contoh $lookup. contoh pipa dengan kondisi

db.posts.aggregate([
 { $lookup:
     {
       from: "comments",
       let: { post_likes: "$likes", post_title: "$title"},
       pipeline: [
            { $match:
                { $expr:
                    { $and:
                        [
                           { $gt: [ "$likes", "$$post_likes"] },
                           { $eq: ["$$post_title", "$postTitle" ] }
                        ]
                    }
                }
            }
        ],
        as: "comments"
        }
 }
])
_

Perhatikan bagaimana $lookup mengambil bidang yang sedikit berbeda. Khususnya field localField dan foreignField telah diganti dengan

  • biarkan (opsional). sebuah ekspresi yang mendefinisikan variabel untuk digunakan dalam tahap pipeline. Ini adalah cara Anda mengakses bidang dari koleksi input di tahap pipeline
  • saluran pipa. pipa agregasi untuk dieksekusi pada koleksi untuk bergabung

Perhatikan bagaimana kita mendefinisikan dua variabel dalam ekspresi let. Kami mendefinisikan post_likes dan post_title sehingga kami dapat mereferensikan dokumen input di tahap pipeline

Ini adalah satu-satunya cara bagi kami untuk membuat perbandingan di berbagai koleksi

{ $gt: [ "$likes", "$$post_likes"] },
{ $eq: ["$$post_title", "$postTitle" ] }

Perhatikan bagaimana kita menggunakan $$ untuk merujuk ke variabel yang kita definisikan di let. Kami mereferensikan bidang dalam koleksi asing dengan satu $

Kueri ini mengembalikan yang berikut ini

{
    "title" : "my first post",
    "author" : "Jim",
    "likes" : 5,
    "comments" : []
},
{
    "title" : "my second post",
    "author" : "Jim",
    "likes" : 2,
    "comments" : [
        {
            "postTitle" : "my second post",
            "comment" : "i liked this post",
            "likes" : 12
        }
    ]
},
{
    "title" : "hello world",
    "author" : "Joe",
    "likes" : 3,
    "comments" : [
        {
            "postTitle" : "hello world",
            "comment" : "not my favorite",
            "likes" : 8
        }
    ]
}
_

Seperti contoh pertama, kueri ini mengembalikan komentar yang postTitle cocok dengan kolom judul untuk setiap posting. Kueri ini menambahkan syarat tambahan untuk mengembalikan komentar yang jumlah sukanya lebih besar dari suka pada kiriman terkait

Dengan menjalankan kueri ini, kami sekarang tahu jika ada kiriman yang memiliki komentar dengan lebih banyak suka daripada kiriman itu sendiri. )

Kesimpulan

Anda sekarang telah melihat dua contoh penggunaan $lookup dalam pipa agregasi. Ingatlah bahwa $lookup dapat digunakan untuk pemeriksaan kesetaraan (contoh pertama) dan juga sub-permintaan yang lebih kompleks (contoh kedua)

Bergantung pada jenis kueri yang Anda jalankan, $lookup akan menggunakan parameter yang sedikit berbeda (biarkan, pipeline vs localField, foreignField)

Untuk informasi lebih lanjut tentang pipa agregasi, pastikan untuk membaca panduan 5 menit ini untuk kerangka kerja agregasi MongoDB

Pikiran Anda?

Bagikan pemikiran Anda

0

JavaLava. 3 Maret 2021

Meskipun bagus bahwa $lookup ada di MongoDb, itu bertentangan dengan setiap alasan mengapa Anda menggunakan MongoDB vs datastore relasional lainnya (MySQL).

Ingat bahwa operasi $lookup disertai dengan biaya untuk melakukan operasi GABUNG pada koleksi Anda. Ingatlah bahwa salah satu keunggulan utama MongoDb adalah kinerja yang lebih cepat dengan data yang tidak terstruktur. ironi.

Untuk ilustrasi lebih lanjut, katakanlah Anda membuat blog menggunakan Mongo. Blog tipikal hadir dengan Pengguna, Posting, Komentar, Suka, Pengikut, dll. Ini banyak HUBUNGAN untuk dikelola. Jika Anda menggunakan MongoDb untuk kasus penggunaan ini, Anda dapat dengan cepat menemukan diri Anda dalam masalah (terutama jika setiap entitas diwakili oleh kumpulannya sendiri. )

Katakanlah Anda ingin menampilkan postingan blog yang paling disukai pengguna. Ini akan membutuhkan satu agregasi Mongo UGLY tempat Anda mengumpulkan suka, komentar, dll untuk posting tertentu. Itu banyak sekali $lookup. dan mulai mengajukan pertanyaan "MENGAPA TIDAK HANYA MENGGUNAKAN SQL"

Singkatnya. tanyakan pada diri Anda apakah Anda membuat keputusan arsitektur yang tepat ketika Anda sering menggunakan $lookup .

0

StackChiefOG. 3 Maret 2021

Hati-hati dengan $lookup

Mengapa? . Ingatlah bahwa MongoDb adalah penyimpanan data non-relasional. Ini berarti unggul dengan sejumlah besar data tidak terstruktur yang membutuhkan pencarian cepat

Saat Anda menggunakan $lookup Anda melakukan penggabungan pada dua koleksi berbeda. Ini adalah data TERSTRUKTUR. Jika Anda mendesain seluruh skema di sekitar penyimpanan data "tanpa skema", maka Anda tidak akan dibayar untuk melakukan apa yang Anda lakukan. )

Penyimpanan data relasional masih memiliki tempatnya. Meskipun ada banyak hype seputar NoSQL, iOT, dan cloud (buzz words), MySQL lama yang bagus dan RDBMS lainnya masih banyak digunakan dalam produksi. dan pada SKALA

Bagaimana cara mendapatkan jumlah total di MongoDB?

metode count() digunakan untuk mengembalikan jumlah dokumen yang cocok dengan kueri find(). db. koleksi. metode count() tidak melakukan operasi find() melainkan menghitung dan mengembalikan jumlah hasil yang cocok dengan kueri.

Bagaimana cara menggunakan kecocokan dengan pencarian di MongoDB?

$lookup melakukan pencocokan kesetaraan pada foreignField ke localField dari dokumen masukan . Jika dokumen dalam koleksi from tidak mengandung foreignField , $lookup memperlakukan nilai sebagai null untuk tujuan pencocokan. Menentukan nama bidang larik baru untuk ditambahkan ke dokumen masukan.

Bagaimana cara menulis kueri penghitungan di MongoDB?

koleksi. count() — Panduan MongoDB. .
kueri dapat menggunakan indeks,
kueri hanya berisi kondisi pada kunci indeks, dan
predikat kueri mengakses satu rentang kunci indeks yang berdekatan

Apa pencarian dalam agregasi untuk MongoDB?

$lookup melakukan pencocokan kesetaraan pada localField ke foreignField dari dokumen koleksi from . Jika dokumen masukan tidak mengandung localField , $lookup memperlakukan bidang tersebut sebagai memiliki nilai null untuk tujuan pencocokan.