How to do SQL INTERSECT OPERATION IN MONGODB - mongodb

Question

SELECT SOME_COLUMN
FROM TABLE
WHERE SOME_COLUMN_NAME = 'VALUE'
INTERSECT
SELECT SOME_COLUMN
FROM TABLE
WHERE SOME_COLUMN_NAME_VALUE = 'NEW_VALUE'
How to get the common or intersection values for the 2 queries (using INTERSECT operator in SQL) in MongoDB?
INTERSECT is a keyword for SQL, how is it done for MongoDB?

Answer 1

As with so many things from SQL, there is no exact counterpart for SQL INTERSECT in MongoDB, but depending on the actual problem there might be an alternative solution.
MongoDB has no operations which affects more than one collection, so creating an intersection between two collections can't be done completely on the database.
When both queries come from the same collection, you could maybe do something with aggregation. What you could do would depend on what you actually want to do.

Answer 2

Your question seems a little off with the statements "VALUE" and "NEWVALUE" in each sub-query portion. The point of INTERSECT is is matching on the column(s) with the "same" value.
But as long as you are talking about the same collection, then you can get the intersection of tho columns using the aggregation framework like so:
db.collection.aggregate([
// Get the "sets" for each field
{ "$group": {
"_id": null,
"field1": { "$addToSet": "$field1" },
"field2": { "$addToSet": "$field2" }
}},
// Intersect the "sets"
"same": { "$setIntersection": [ "$field1", "$field2" ] }
}},
// Unwind the result set
{ "$unwind": "$same" },
// Just project the wanted field
{ "$project": { "_id": 0, "same": 1 } }
])
That does make use of the $setIntersection operator introduced in MongoDB 2.6 in order to return a "set" with the common elements from the two "sets" being compared. The $addToSet operation constructs the two sets from the "unique" values in each field.
You can essentially do the same thing if your available MongoDB version is prior to 2.6, but just with a little more work:
db.collection.aggregate([
// Group each "set"
{ "$group": {
"_id": null,
"field1": { "$addToSet": "$field1" },
"field2": { "$addToSet": "$field2" }
}},
// Unwind each set
{ "$unwind": "$field1" },
{ "$unwind": "$field2" },
// Group on the compared values
{ "$group": {
"_id": null,
"same": {
"$addToSet": {
"$cond": [
{ "$eq": [ "$field1", "$field2" ] },
"$field1",
false
]
}
}
}},
// Unwind again, should be compacted now
{ "$unwind": "$same" },
// Filter out the "false" values
{ "$match": { "same": { "$ne": false } } },
// Just project the wanted field
{ "$project": { "_id": 0, "same": 1 } }
])
Lacking support for the "set operators" in earlier versions, you just emulate the behavior by comparing the values of the two "sets". This largely works as when you $unwind an array, what is produced is essentially a new document for each of those values. So "unwinding" an array on top of another results in documents where each element can be compared against the other.
So with the single collection form this is a perfectly valid operation in order to get the "intersection". Like all things in MongoDB though, the general gearing is towards working with a single collection at a time. The general onus is on your design to structure the data so that comparisons are made on a single collection.
Similar results can be obtained with an incremental mapReduce process over multiple collections, but as your general question seems to refer to a single table source then this would in fact be a different question to the one you appear to be asking. Also of course, it is not a single operation and involves multiple processing steps.
You would generally be advised to take a good look at the manual section on SQL to aggregation mapping. This gives many common examples and is getting better over time to add additional use cases.