mongoose nodeJs, группа по внешнему ключу, где ID находится в массиве [duplicate]

Что касается Монго 3.2, ответы на этот вопрос больше не верны. Новый оператор $ lookup, добавленный в конвейер агрегации, по существу идентичен левому внешнему соединению:

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

Из документов:

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

Конечно, Mongo является не реляционной базой данных, а разработчики стараются рекомендовать конкретные варианты использования для $ lookup, но по крайней мере, начиная с 3.2, соединение теперь возможно с MongoDB.

Вы можете присоединиться к двум коллекциям в Монго, используя поиск, который предлагается в версии 3.2. В вашем случае запрос будет

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

, или вы также можете присоединиться к пользователям, тогда будет небольшое изменение, как указано ниже.

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

Он будет работать так же, как левое и правое соединение в SQL.

До 3.2.6 Mongodb не поддерживает запрос соединения как mysql. ниже решения, которое работает для вас.

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

При правильной комбинации $ lookup, $ project и $ match вы можете присоединиться к нескольким таблицам по нескольким параметрам. Это связано с тем, что они могут быть связаны несколько раз.

Предположим, что мы хотим сделать следующее ( reference )

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

Шаг 1: Свяжите все таблицы

, вы можете $ lookup сколько угодно таблиц.

$ lookup - по одному для каждой таблицы в запросе

$ unwind - поскольку данные денормализированы правильно, иначе они завернуты в массивы

Python code ..

db.LeftTable.aggregate([
                        # connect all tables

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

                        ])

Шаг 2: Определите все условные выражения

$ project: определите здесь все условные операторы и все переменные, которые вы хотите выбрать.

Python Code ..

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

Шаг 3: Присоедините все условные обозначения

$ match - присоедините все условия, используя OR или AND и т. д. Их могут быть кратные ,

$ project: undefine all conditionals

Python Code ..

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

                        ])

Практически любая комбинация таблиц, условных обозначений и объединений может быть выполнена таким образом ,

$ lookup (aggregation)

Выполняет левое внешнее соединение в незащищенном наборе в той же базе данных для фильтрации в документах из «объединенной» коллекции для обработки. Для каждого входного документа этап $ lookup добавляет новое поле массива, элементы которого являются соответствующими документами из «объединенной» коллекции. Эта стадия $ lookup передает эти измененные документы на следующий этап. Этап $ lookup имеет следующие синтаксисы:

Equality Match

Чтобы выполнить совпадение равенства между полем из входных документов с полем из документов «объединенной» коллекции, этап $ lookup имеет следующий синтаксис:

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

Операция будет соответствовать следующему выражению псевдо-SQL:

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

Mongo URL

Вот пример коллекции "join" * Актеры и фильмы:

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

Использует метод .mapReduce()

* join - альтернативу объединению в документарно-ориентированных базах данных

Мы можем объединить две коллекции, используя sub-запрос mongoDB. Вот пример, Комментарии -

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

Пользователи -

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

Суб-запрос MongoDB для JOIN -

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

Получить результат из недавно созданная коллекция -

db.newCommentUsers.find().pretty()

Результат -

`{
    "_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"
        }
    ]
}`

Надеюсь, что это поможет.

Эта страница на официальном сайте mongodb адресует точно этот вопрос:

http://docs.mongodb.org/ecosystem/tutorial/model-data- for-ruby-on-rails /

Когда мы показываем наш список историй, нам нужно будет показать имя пользователя, разместившего историю. Если бы мы использовали реляционную базу данных, мы могли бы выполнить соединение с пользователями и магазинами и получить все наши объекты в одном запросе. Но MongoDB не поддерживает объединения, и поэтому время от времени требуется бит денормализации. Здесь это означает кеширование атрибута «имя пользователя».

Реляционные пуристы уже чувствуют себя неловко, как будто мы нарушаем какой-то универсальный закон. Но давайте иметь в виду, что коллекции MongoDB не эквивалентны реляционным таблицам; каждая из которых служит уникальной проектной цели. Нормализованная таблица обеспечивает атомный изолированный кусок данных. Однако документ более тесно представляет собой объект в целом. В случае сайта социальных новостей можно утверждать, что имя пользователя является неотъемлемой частью истории, опубликованной.

Вы можете сделать это, используя конвейер агрегации, но это боль, чтобы написать его самостоятельно.

Вы можете использовать mongo-join-query , чтобы автоматически создать конвейер агрегации из вашего запроса.

Так будет выглядеть ваш запрос:

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))
);

Ваш результат будет иметь пользовательский объект в поле uid, и вы можете связать столько уровней, сколько хотите. Вы можете заполнить ссылку на пользователя, которая ссылается на команду, которая ссылается на что-то еще и т. Д.

Отказ от ответственности: я написал mongo-join-query для решения этой точной проблемы.

Вы можете запускать SQL-запросы, включая объединение на MongoDB с mongo_fdw из Postgres.

Нет, похоже, что вы делаете это неправильно. Соединения MongoDB являются «клиентской стороной». Очень похоже на то, что вы сказали:

На данный момент я получаю комментарии, соответствующие моим критериям, затем выясняя все uid в этом наборе результатов, получая пользовательские объекты и объединяя их с комментариями. Похоже, я делаю это неправильно.

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.

Это не «реальное» соединение, но на самом деле оно намного полезнее, чем соединение SQL, потому что вам не нужно иметь дело с дубликатом строки для «многих» сторонних объединений, вместо этого вы украшаете первоначально выбранный набор.

На этой странице много глупостей и FUD. Оказывается, 5 лет спустя MongoDB все еще есть.