The process of retrieving matching strings from two collections in MongoDB

Question

The process of retrieving matching strings from two collections in MongoDB

There are two collections: Collection A consists of:

-> {"_id": .... , "data":"demon"}
-> {"_id": .... , "data":"god"}

and Collection B consists of:

-> {"_id": .... , "title": "Book A", "description": "this book is about a demon."}
-> {"_id": .... , "title": "Book B", "description": "this book is about a god from Greek."}
-> {"_id": .... , "title": "Book C", "description": "this book is about a dog."}

The task at hand is to retrieve documents from Collection B where the description does not contain any text present in the "data" field of Collection A.

To achieve this in Mongo Query using Plain JS:

collectionA.filter( x => { return !collectionB.some(y => x.description.includes(y.data)});

So the question remains, how can this be accomplished in MongoDB?

javascript mongodb mongodb-query

Answer 1

Answer №1

Although this code snippet seems to achieve the desired outcome, its efficiency may be questionable when dealing with large datasets.

db.A.aggregate([
    {
        $project: {
            _id: 0,
            data: 1
        }
    },
    {
        $lookup:
        {
            from: 'B',
            let: { word: '$data' },
            pipeline: [
                {
                    $match: {
                        $expr: {
                            $regexMatch: {
                                input: '$description',
                                regex: '$$word'
                            }
                        }
                    }
                },
                {
                    $project: { _id: 1 }
                }
            ],
            as: 'found'
        }
    },
    {
        $group: {
            _id: null,
            ids: {
                $addToSet: {
                    $arrayElemAt: ['$found', 0]
                }
            }
        }
    },
    {
        $set: {
            ids: {
                $map: {
                    input: '$ids',
                    in: '$$this._id'
                }
            }
        }
    },
    {
        $lookup: {
            from: 'B',
            let: { found_ids: '$ids' },
            pipeline: [
                {
                    $match: {
                        $expr: {
                            $not: {
                                $in: ['$_id', '$$found_ids']
                            }
                        }
                    }
                }
            ],
            as: 'docs'
        }
    },
    {
        $unwind: '$docs'
    },
    {
        $replaceWith: '$docs'
    }
])

https://mongoplayground.net/p/YMrYeiUOQdo

Answer 2

Although this code snippet seems to achieve the desired outcome, its efficiency may be questionable when dealing with large datasets.

db.A.aggregate([
    {
        $project: {
            _id: 0,
            data: 1
        }
    },
    {
        $lookup:
        {
            from: 'B',
            let: { word: '$data' },
            pipeline: [
                {
                    $match: {
                        $expr: {
                            $regexMatch: {
                                input: '$description',
                                regex: '$$word'
                            }
                        }
                    }
                },
                {
                    $project: { _id: 1 }
                }
            ],
            as: 'found'
        }
    },
    {
        $group: {
            _id: null,
            ids: {
                $addToSet: {
                    $arrayElemAt: ['$found', 0]
                }
            }
        }
    },
    {
        $set: {
            ids: {
                $map: {
                    input: '$ids',
                    in: '$$this._id'
                }
            }
        }
    },
    {
        $lookup: {
            from: 'B',
            let: { found_ids: '$ids' },
            pipeline: [
                {
                    $match: {
                        $expr: {
                            $not: {
                                $in: ['$_id', '$$found_ids']
                            }
                        }
                    }
                }
            ],
            as: 'docs'
        }
    },
    {
        $unwind: '$docs'
    },
    {
        $replaceWith: '$docs'
    }
])

https://mongoplayground.net/p/YMrYeiUOQdo

The process of retrieving matching strings from two collections in MongoDB

Answer №1

Similar questions

Encountering a NullPointerException when running a basic test on Mongo-Hadoop

What causes errors in URL routeProvider with AngularJS?

Showing the initials of a user at the top of an SVG using ReactJS

Attempting to run the npm install command led to encountering a SyntaxError with an

Unable to retrieve data from mongoDB, received an HTML template instead of the expected data

children blocking clicks on their parents' divs

Combine two events in jQuery using the AND operator

Forwarding requests via middleware in next.js 13 AppDir: true

Simple method for sending a JavaScript array or its data to a servlet utilizing jQuery's ajax() functionality

The execution of the Ajax success call is failing to take place

Is there a way to submit a form without navigating away from the current webpage?

Compatibility between pymongo version 4.1.1 and mongoengine

Why is JavaScript unable to fetch JSON data from C when the uint32 value is a multiple of 256 plus 10?

Is utilizing web workers for numerous simultaneous intensive computations a viable strategy?

Multiplication cannot be performed on operands of type 'NoneType'

What is the best way to symbolize a breadcrumb offspring?

Have you ever wondered how the automatic video play on scroll feature works on Tiktok.com and YouTube shorts when using a mobile device?

How can one determine if there are additional documents available for pagination within MongoDB?

Enhance information flow within pages using SWR in NextJS

What is the best way to store a username and password within a JavaScript object in ReactJS?