Bagaimana saya melakukan yang setara SQL Join di MongoDB?

Bagaimana saya melakukan yang setara SQL Join di MongoDB?

Misalnya, Anda memiliki dua koleksi (pengguna dan komentar) dan saya ingin menarik semua komentar dengan pid = 444 bersama dengan info pengguna untuk masing-masing.

comments
  { uid:12345, pid:444, comment="blah" }
  { uid:12345, pid:888, comment="asdf" }
  { uid:99999, pid:444, comment="qwer" }

users
  { uid:12345, name:"john" }
  { uid:99999, name:"mia"  }

Apakah ada cara untuk menarik semua komentar dengan bidang tertentu (mis. ... find ({pid: 444})) dan informasi pengguna yang terkait dengan setiap komentar dalam sekali jalan?

Saat ini, saya pertama-tama mendapatkan komentar yang sesuai dengan kriteria saya, kemudian mencari tahu semua uid di set hasil itu, mendapatkan objek pengguna, dan menggabungkannya dengan hasil komentar. Sepertinya saya salah melakukannya.

Pada Mongo 3.2 jawaban untuk pertanyaan ini sebagian besar tidak lagi benar. Operator $ lookup baru yang ditambahkan ke pipa agregasi pada dasarnya identik dengan gabungan luar kiri:

https://docs.mongodb.org/master/reference/operator/aggregation/lookup/#pipe._S_lookup

Dari dokumen:

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       as: <output array field>
     }
}

Tentu saja Mongo bukan database relasional, dan para pengembang sedang berhati-hati untuk merekomendasikan kasus penggunaan khusus untuk $ lookup, tetapi setidaknya pada 3.2 melakukan join sekarang dimungkinkan dengan MongoDB.

Halaman ini di situs mongodb resmi menjawab persis pertanyaan ini:

https://mongodb-documentation.readthedocs.io/en/latest/ecosystem/tutorial/model-data-for-ruby-on-rails.html

Saat kami menampilkan daftar cerita kami, kami harus menunjukkan nama pengguna yang memposting cerita. Jika kami menggunakan basis data relasional, kami dapat melakukan gabungan pada pengguna dan toko, dan mendapatkan semua objek kami dalam satu permintaan. Tetapi MongoDB tidak mendukung bergabung dan karenanya, kadang-kadang, memerlukan sedikit denormalization. Di sini, ini berarti caching atribut 'nama pengguna'.

Puritan relasional mungkin sudah merasa tidak nyaman, seolah-olah kita melanggar beberapa hukum universal. Tapi mari kita ingat bahwa koleksi MongoDB tidak setara dengan tabel relasional; masing-masing melayani tujuan desain yang unik. Tabel yang dinormalisasi menyediakan potongan data atomik yang terisolasi. Namun, sebuah dokumen lebih dekat merepresentasikan objek secara keseluruhan. Dalam kasus situs berita sosial, dapat dikatakan bahwa nama pengguna adalah intrinsik dari cerita yang diposting.

Kami dapat menggabungkan / menggabungkan semua data hanya dalam satu koleksi dengan fungsi yang mudah dalam beberapa baris menggunakan konsol klien mongodb, dan sekarang kami dapat dapat melakukan permintaan yang diinginkan. Di bawah contoh lengkap,

.- Penulis:

db.authors.insert([
    {
        _id: 'a1',
        name: { first: 'orlando', last: 'becerra' },
        age: 27
    },
    {
        _id: 'a2',
        name: { first: 'mayra', last: 'sanchez' },
        age: 21
    }
]);

.- Kategori:

db.categories.insert([
    {
        _id: 'c1',
        name: 'sci-fi'
    },
    {
        _id: 'c2',
        name: 'romance'
    }
]);

.- Buku

db.books.insert([
    {
        _id: 'b1',
        name: 'Groovy Book',
        category: 'c1',
        authors: ['a1']
    },
    {
        _id: 'b2',
        name: 'Java Book',
        category: 'c2',
        authors: ['a1','a2']
    },
]);

.- Peminjaman buku

db.lendings.insert([
    {
        _id: 'l1',
        book: 'b1',
        date: new Date('01/01/11'),
        lendingBy: 'jose'
    },
    {
        _id: 'l2',
        book: 'b1',
        date: new Date('02/02/12'),
        lendingBy: 'maria'
    }
]);

.- Sihir:

db.books.find().forEach(
    function (newBook) {
        newBook.category = db.categories.findOne( { "_id": newBook.category } );
        newBook.lendings = db.lendings.find( { "book": newBook._id  } ).toArray();
        newBook.authors = db.authors.find( { "_id": { $in: newBook.authors }  } ).toArray();
        db.booksReloaded.insert(newBook);
    }
);

.- Dapatkan data pengumpulan baru:

db.booksReloaded.find().pretty()

.- Respon :)

{
    "_id" : "b1",
    "name" : "Groovy Book",
    "category" : {
        "_id" : "c1",
        "name" : "sci-fi"
    },
    "authors" : [
        {
            "_id" : "a1",
            "name" : {
                "first" : "orlando",
                "last" : "becerra"
            },
            "age" : 27
        }
    ],
    "lendings" : [
        {
            "_id" : "l1",
            "book" : "b1",
            "date" : ISODate("2011-01-01T00:00:00Z"),
            "lendingBy" : "jose"
        },
        {
            "_id" : "l2",
            "book" : "b1",
            "date" : ISODate("2012-02-02T00:00:00Z"),
            "lendingBy" : "maria"
        }
    ]
}
{
    "_id" : "b2",
    "name" : "Java Book",
    "category" : {
        "_id" : "c2",
        "name" : "romance"
    },
    "authors" : [
        {
            "_id" : "a1",
            "name" : {
                "first" : "orlando",
                "last" : "becerra"
            },
            "age" : 27
        },
        {
            "_id" : "a2",
            "name" : {
                "first" : "mayra",
                "last" : "sanchez"
            },
            "age" : 21
        }
    ],
    "lendings" : [ ]
}

Saya harap kalimat ini dapat membantu Anda.

Anda harus melakukannya dengan cara yang Anda gambarkan. MongoDB adalah basis data non-relasional dan tidak mendukung gabungan.

Seperti yang orang lain tunjukkan, Anda mencoba membuat database relasional dari tidak ada database relasional yang sebenarnya tidak ingin Anda lakukan selain itu, jika Anda memiliki kasus yang harus Anda lakukan di sini, ini adalah solusi yang dapat Anda gunakan. Kami pertama-tama melakukan pencarian foreach pada koleksi A (atau dalam kasus pengguna Anda) dan kemudian kami mendapatkan setiap item sebagai objek kemudian kami menggunakan properti objek (dalam kasus Anda) untuk mencari dalam koleksi kedua kami (dalam komentar kasus Anda) jika kami dapat menemukannya maka kami memiliki kecocokan dan kami dapat mencetak atau melakukan sesuatu dengannya. Semoga ini bisa membantu Anda dan semoga berhasil :)

db.users.find().forEach(
function (object) {
    var commonInBoth=db.comments.findOne({ "uid": object.uid} );
    if (commonInBoth != null) {
        printjson(commonInBoth) ;
        printjson(object) ;
    }else {
        // did not match so we don't care in this case
    }
});

Dengan kombinasi yang tepat dari $ lookup , $ project dan $ match , Anda dapat bergabung dengan tabel mutiple pada beberapa parameter. Ini karena mereka dapat dirantai beberapa kali.

Misalkan kita ingin melakukan hal berikut ( referensi )

SELECT S.* FROM LeftTable S
LEFT JOIN RightTable R ON S.ID =R.ID AND S.MID =R.MID WHERE R.TIM >0 AND 
S.MOB IS NOT NULL

Langkah 1: Tautkan semua tabel

Anda dapat $ mencari tabel sebanyak yang Anda inginkan.

$ lookup - satu untuk setiap tabel dalam kueri

$ melepas - karena data dinormalisasi dengan benar, kalau tidak dibungkus dalam array

Kode python ..

db.LeftTable.aggregate([
                        # connect all tables

                        {"$lookup": {
                          "from": "RightTable",
                          "localField": "ID",
                          "foreignField": "ID",
                          "as": "R"
                        }},
                        {"$unwind": "R"}

                        ])

Langkah 2: Tentukan semua persyaratan

$ proyek : tentukan semua pernyataan kondisional di sini, ditambah semua variabel yang ingin Anda pilih.

Kode Python ..

db.LeftTable.aggregate([
                        # connect all tables

                        {"$lookup": {
                          "from": "RightTable",
                          "localField": "ID",
                          "foreignField": "ID",
                          "as": "R"
                        }},
                        {"$unwind": "R"},

                        # define conditionals + variables

                        {"$project": {
                          "midEq": {"$eq": ["$MID", "$R.MID"]},
                          "ID": 1, "MOB": 1, "MID": 1
                        }}
                        ])

Langkah 3: Bergabunglah dengan semua persyaratan

$ match - gabung semua ketentuan menggunakan ATAU DAN DAN dll. Ada beberapa hal berikut.

$ project : batalkan semua persyaratan

Kode Python ..

db.LeftTable.aggregate([
                        # connect all tables

                        {"$lookup": {
                          "from": "RightTable",
                          "localField": "ID",
                          "foreignField": "ID",
                          "as": "R"
                        }},
                        {"$unwind": "$R"},

                        # define conditionals + variables

                        {"$project": {
                          "midEq": {"$eq": ["$MID", "$R.MID"]},
                          "ID": 1, "MOB": 1, "MID": 1
                        }},

                        # join all conditionals

                        {"$match": {
                          "$and": [
                            {"R.TIM": {"$gt": 0}}, 
                            {"MOB": {"$exists": True}},
                            {"midEq": {"$eq": True}}
                        ]}},

                        # undefine conditionals

                        {"$project": {
                          "midEq": 0
                        }}

                        ])

Kombinasi tabel, kondisional, dan gabungan dapat dilakukan dengan cara ini.

Berikut ini contoh koleksi "gabungan" * Aktor dan Film :

https://github.com/mongodb/cookbook/blob/master/content/patterns/pivot.txt

Itu menggunakan .mapReduce()metode

* bergabung - alternatif untuk bergabung dalam basis data berorientasi dokumen

Anda dapat bergabung dengan dua koleksi di Mongo dengan menggunakan pencarian yang ditawarkan dalam versi 3.2. Dalam kasus Anda, kueri akan menjadi

db.comments.aggregate({
    $lookup:{
        from:"users",
        localField:"uid",
        foreignField:"uid",
        as:"users_comments"
    }
})

atau Anda juga dapat bergabung sehubungan dengan pengguna maka akan ada sedikit perubahan seperti yang diberikan di bawah ini.

db.users.aggregate({
    $lookup:{
        from:"comments",
        localField:"uid",
        foreignField:"uid",
        as:"users_comments"
    }
})

Ini akan berfungsi sama seperti bergabung kiri dan kanan dalam SQL.

Itu tergantung pada apa yang Anda coba lakukan.

Anda saat ini mengaturnya sebagai database yang dinormalisasi, yang baik-baik saja, dan cara Anda melakukannya sesuai.

Namun, ada cara lain untuk melakukannya.

Anda bisa memiliki koleksi posting yang telah menanamkan komentar untuk setiap posting dengan referensi ke pengguna yang Anda bisa dapatkan secara iteratif. Anda dapat menyimpan nama pengguna dengan komentar, Anda dapat menyimpan semuanya dalam satu dokumen.

Masalahnya dengan NoSQL adalah dirancang untuk skema fleksibel dan membaca dan menulis yang sangat cepat. Dalam sebuah peternakan Big Data khas, basis data adalah hambatan terbesar, Anda memiliki lebih sedikit mesin basis data daripada aplikasi dan server ujung depan ... mereka lebih mahal tetapi lebih kuat, juga ruang hard drive relatif murah. Normalisasi datang dari konsep mencoba menghemat ruang, tetapi ia datang dengan biaya untuk membuat database Anda berkinerja rumit. Bergabung dan memverifikasi integritas hubungan, melakukan operasi kaskade. Semua yang menyimpan sakit kepala pengembang jika mereka mendesain database dengan benar.

Dengan NoSQL, jika Anda menerima bahwa redundansi dan ruang penyimpanan tidak menjadi masalah karena biayanya (baik dalam waktu prosesor yang diperlukan untuk melakukan pembaruan dan biaya hard drive untuk menyimpan data tambahan), denormalisasi bukan merupakan masalah (untuk array tertanam yang menjadi ratusan ribu item itu bisa menjadi masalah kinerja, tetapi sebagian besar waktu itu bukan masalah). Selain itu, Anda akan memiliki beberapa aplikasi dan server ujung depan untuk setiap cluster basis data. Mintalah mereka melakukan angkat berat dari gabungan dan biarkan server database tetap membaca dan menulis.

TL; DR: Apa yang Anda lakukan baik-baik saja, dan ada cara lain untuk melakukannya. Lihat pola model data dokumentasi mongodb untuk beberapa contoh hebat. http://docs.mongodb.org/manual/data-modeling/

Ada spesifikasi yang didukung banyak driver yang disebut DBRef.

DBRef adalah spesifikasi yang lebih formal untuk membuat referensi antar dokumen. DBRefs (umumnya) menyertakan nama koleksi dan juga id objek. Sebagian besar pengembang hanya menggunakan DBRefs jika koleksi dapat berubah dari satu dokumen ke yang berikutnya. Jika koleksi Anda yang dirujuk akan selalu sama, referensi manual yang diuraikan di atas lebih efisien.

Diambil dari Dokumentasi MongoDB: Model Data> Referensi Model Data> Referensi Database

$ lookup (agregasi)

Melakukan gabungan luar kiri ke koleksi yang tidak di-shard di database yang sama untuk memfilter dalam dokumen dari koleksi "bergabung" untuk diproses. Untuk setiap dokumen input, tahap $ lookup menambahkan bidang array baru yang unsur-unsurnya adalah dokumen yang cocok dari koleksi "bergabung". Tahap $ lookup melewati dokumen-dokumen yang dibentuk kembali ini ke tahap berikutnya. Tahap $ lookup memiliki sintaks berikut:

Pencocokan Kesetaraan

Untuk melakukan kecocokan kesetaraan antara bidang dari dokumen input dengan bidang dari dokumen koleksi "gabungan", tahap $ lookup memiliki sintaks berikut:

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       as: <output array field>
     }
}

Operasi akan sesuai dengan pernyataan pseudo-SQL berikut:

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (SELECT <documents as determined from the pipeline>
                               FROM <collection to join>
                               WHERE <pipeline> );

URL Mongo

Sebelum 3.2.6 , Mongodb tidak mendukung permintaan bergabung seperti mysql. solusi di bawah ini yang bekerja untuk Anda.

 db.getCollection('comments').aggregate([
        {$match : {pid : 444}},
        {$lookup: {from: "users",localField: "uid",foreignField: "uid",as: "userData"}},
   ])

Anda dapat menjalankan query SQL termasuk bergabung di MongoDB dengan mongo_fdw dari Postgres.

MongoDB tidak mengizinkan bergabung, tetapi Anda bisa menggunakan plugin untuk mengatasinya. Periksa plugin mongo-gabung. Ini yang terbaik dan saya sudah menggunakannya. Anda dapat menginstalnya menggunakan npm secara langsung seperti ini npm install mongo-join. Anda dapat melihat dokumentasi lengkapnya dengan contoh .

(++) alat yang sangat membantu ketika kita perlu bergabung (N) koleksi

(-) kami dapat menerapkan kondisi hanya pada tingkat atas permintaan

Contoh

var Join = require('mongo-join').Join, mongodb = require('mongodb'), Db = mongodb.Db, Server = mongodb.Server;
db.open(function (err, Database) {
    Database.collection('Appoint', function (err, Appoints) {

        /* we can put conditions just on the top level */
        Appoints.find({_id_Doctor: id_doctor ,full_date :{ $gte: start_date },
            full_date :{ $lte: end_date }}, function (err, cursor) {
            var join = new Join(Database).on({
                field: '_id_Doctor', // <- field in Appoints document
                to: '_id',         // <- field in User doc. treated as ObjectID automatically.
                from: 'User'  // <- collection name for User doc
            }).on({
                field: '_id_Patient', // <- field in Appoints doc
                to: '_id',         // <- field in User doc. treated as ObjectID automatically.
                from: 'User'  // <- collection name for User doc
            })
            join.toArray(cursor, function (err, joinedDocs) {

                /* do what ever you want here */
                /* you can fetch the table and apply your own conditions */
                .....
                .....
                .....


                resp.status(200);
                resp.json({
                    "status": 200,
                    "message": "success",
                    "Appoints_Range": joinedDocs,


                });
                return resp;


            });

    });

Anda dapat melakukannya menggunakan pipa agregasi, tetapi sulit untuk menulisnya sendiri.

Anda dapat menggunakan mongo-join-queryuntuk membuat pipa agregasi secara otomatis dari permintaan Anda.

Seperti inilah tampilan kueri Anda:

const mongoose = require("mongoose");
const joinQuery = require("mongo-join-query");

joinQuery(
    mongoose.models.Comment,
    {
        find: { pid:444 },
        populate: ["uid"]
    },
    (err, res) => (err ? console.log("Error:", err) : console.log("Success:", res.results))
);

Hasil Anda akan memiliki objek pengguna di uidbidang dan Anda dapat menautkan level sedalam yang Anda inginkan. Anda dapat mengisi referensi ke pengguna, yang membuat referensi ke Tim, yang membuat referensi ke sesuatu yang lain, dll.

Penafian : Saya menulis mongo-join-queryuntuk mengatasi masalah ini.

playORM dapat melakukannya untuk Anda menggunakan S-SQL (Scalable SQL) yang hanya menambahkan partisi sehingga Anda dapat melakukan penggabungan di dalam partisi.

Tidak, sepertinya Anda tidak melakukan kesalahan. Gabungan MongoDB adalah "sisi klien". Seperti yang Anda katakan:

Saat ini, saya pertama-tama mendapatkan komentar yang sesuai dengan kriteria saya, kemudian mencari tahu semua uid di set hasil itu, mendapatkan objek pengguna, dan menggabungkannya dengan hasil komentar. Sepertinya saya salah melakukannya.

1) Select from the collection you're interested in.
2) From that collection pull out ID's you need
3) Select from other collections
4) Decorate your original results.

Ini bukan "nyata" bergabung, tapi itu sebenarnya jauh lebih berguna daripada SQL bergabung karena Anda tidak harus berurusan dengan baris duplikat untuk "banyak" bergabung dengan sisi, sebagai gantinya Anda menghias set yang dipilih sebelumnya.

Ada banyak omong kosong dan FUD di halaman ini. Ternyata 5 tahun kemudian MongoDB masih menjadi masalah.

Saya pikir, jika Anda memerlukan tabel data yang dinormalisasi - Anda perlu mencoba beberapa solusi database lainnya.

Tapi saya sudah menyelesaikan solusi untuk MOngo di Git By the way, dalam kode sisipan - ia memiliki nama film, tetapi ID film noi .

Masalah

Anda memiliki koleksi Aktor dengan berbagai Film yang telah mereka lakukan.

Anda ingin menghasilkan koleksi Film dengan berbagai Aktor di masing-masing.

Beberapa sampel data

 db.actors.insert( { actor: "Richard Gere", movies: ['Pretty Woman', 'Runaway Bride', 'Chicago'] });
 db.actors.insert( { actor: "Julia Roberts", movies: ['Pretty Woman', 'Runaway Bride', 'Erin Brockovich'] });

Larutan

Kita perlu mengulang setiap film dalam dokumen Aktor dan memancarkan setiap Film satu per satu.

Tangkapan di sini sedang dalam fase reduksi. Kami tidak dapat memancarkan array dari fase pengurangan, jadi kami harus membuat array Aktor di dalam dokumen "nilai" yang dikembalikan.

map = function() {
  for(var i in this.movies){
    key = { movie: this.movies[i] };
    value = { actors: [ this.actor ] };
    emit(key, value);
  }
}

reduce = function(key, values) {
  actor_list = { actors: [] };
  for(var i in values) {
    actor_list.actors = values[i].actors.concat(actor_list.actors);
  }
  return actor_list;
}

Perhatikan bagaimana actor_list sebenarnya adalah objek javascript yang berisi larik. Perhatikan juga bahwa peta memancarkan struktur yang sama.

Jalankan yang berikut ini untuk menjalankan peta / kurangi, tampilkan ke koleksi "pivot" dan cetak hasilnya:

printjson (db.actors.mapReduce (peta, kurangi, "pivot")); db.pivot.find (). forEach (printjson);

Berikut adalah contoh output, perhatikan bahwa "Pretty Woman" dan "Runaway Bride" memiliki "Richard Gere" dan "Julia Roberts".

{ "_id" : { "movie" : "Chicago" }, "value" : { "actors" : [ "Richard Gere" ] } }
{ "_id" : { "movie" : "Erin Brockovich" }, "value" : { "actors" : [ "Julia Roberts" ] } }
{ "_id" : { "movie" : "Pretty Woman" }, "value" : { "actors" : [ "Richard Gere", "Julia Roberts" ] } }
{ "_id" : { "movie" : "Runaway Bride" }, "value" : { "actors" : [ "Richard Gere", "Julia Roberts" ] } }

Kami dapat menggabungkan dua koleksi dengan menggunakan kueri mongoDB. Berikut ini contohnya, Komentar -

`db.commentss.insert([
  { uid:12345, pid:444, comment:"blah" },
  { uid:12345, pid:888, comment:"asdf" },
  { uid:99999, pid:444, comment:"qwer" }])`

Userss--

db.userss.insert([
  { uid:12345, name:"john" },
  { uid:99999, name:"mia"  }])

Sub-permintaan MongoDB untuk JOIN--

`db.commentss.find().forEach(
    function (newComments) {
        newComments.userss = db.userss.find( { "uid": newComments.uid } ).toArray();
        db.newCommentUsers.insert(newComments);
    }
);`

Dapatkan hasil dari Collection-- yang baru dibuat

db.newCommentUsers.find().pretty()

Hasil--

`{
    "_id" : ObjectId("5511236e29709afa03f226ef"),
    "uid" : 12345,
    "pid" : 444,
    "comment" : "blah",
    "userss" : [
        {
            "_id" : ObjectId("5511238129709afa03f226f2"),
            "uid" : 12345,
            "name" : "john"
        }
    ]
}
{
    "_id" : ObjectId("5511236e29709afa03f226f0"),
    "uid" : 12345,
    "pid" : 888,
    "comment" : "asdf",
    "userss" : [
        {
            "_id" : ObjectId("5511238129709afa03f226f2"),
            "uid" : 12345,
            "name" : "john"
        }
    ]
}
{
    "_id" : ObjectId("5511236e29709afa03f226f1"),
    "uid" : 99999,
    "pid" : 444,
    "comment" : "qwer",
    "userss" : [
        {
            "_id" : ObjectId("5511238129709afa03f226f3"),
            "uid" : 99999,
            "name" : "mia"
        }
    ]
}`

Semoga ini bisa membantu.