배열 쿼리하기: $all, $size, 요소 일치

Arrays as First-Class Citizens

// Documents with array fields
db.products.insertMany([
  { name: 'Laptop', tags: ['electronics', 'computers', 'portable'] },
  { name: 'Mouse', tags: ['electronics', 'peripherals'] },
  { name: 'Book', tags: ['education', 'reading'] }
]);

Simple Array Equality Queries

// Find products tagged 'electronics'
// MongoDB checks if 'electronics' is an element of the tags array
db.products.find({ tags: 'electronics' });
// Returns Laptop and Mouse (both have 'electronics' in tags)

// This also works on arrays of numbers
db.scores.find({ values: 95 });
// Matches { values: [80, 95, 72] }

The $all Operator

// Find products tagged BOTH 'electronics' AND 'portable'
db.products.find({
  tags: { $all: ['electronics', 'portable'] }
});
// Returns Laptop (has both tags)
// Does NOT return Mouse (missing 'portable')

// Order of values in $all does not matter
db.products.find({
  tags: { $all: ['portable', 'electronics'] }  // same result
});

The $size Operator

// Find products with exactly 3 tags
db.products.find({ tags: { $size: 3 } });
// Returns Laptop (tags has 3 elements)

// $size does NOT support ranges:
// db.products.find({ tags: { $size: { $gt: 2 } } }); // INVALID

// Workaround: store the count as a field
db.products.updateMany({}, [{ $set: { tagCount: { $size: '$tags' } } }]);
db.products.find({ tagCount: { $gt: 2 } });  // range check on stored count

Matching by Array Index

// Documents: { name: 'Alice', scores: [100, 85, 92] }
//            { name: 'Bob',   scores: [75, 88, 91] }

// Find documents where the FIRST score is 100
db.results.find({ 'scores.0': 100 });
// Returns Alice

// Find where SECOND element is greater than 85
db.results.find({ 'scores.1': { $gt: 85 } });
// Returns Bob (scores[1] = 88 > 85) and Alice (85 is NOT > 85)

The Spread Field Problem

// Documents:
// { scores: [{ value: 95, grade: 'A' }, { value: 60, grade: 'D' }] }
// { scores: [{ value: 92, grade: 'B' }, { value: 72, grade: 'C' }] }

// This filter has SPREAD FIELD issue:
// Matches doc1 (value 95>90 is in scores[0], grade 'A' is in scores[0] - fine here)
// Also matches doc2 if value 92>90 from one element + some 'B'... but what if:
// { scores: [{ value: 91, grade: 'B' }, { value: 62, grade: 'A' }] }
// This would ALSO match! 91 > 90 from element[0] + grade 'A' from element[1]

$elemMatch for Multi-Condition Array Queries

// Find documents where a SINGLE scores element has value > 90 AND grade 'A'
db.results.find({
  scores: {
    $elemMatch: {
      value: { $gt: 90 },
      grade: 'A'
    }
  }
});
// Only matches if one element has BOTH value > 90 AND grade 'A'

$elemMatch for Scalar Arrays

// Find docs where a SINGLE element is between 10 and 20
db.measurements.find({
  values: { $elemMatch: { $gt: 10, $lt: 20 } }
});
// { values: [5, 15, 25] } - matches (15 satisfies both)
// { values: [5, 30] }     - does NOT match

// Without $elemMatch (wrong - tests across elements):
db.measurements.find({ values: { $gt: 10, $lt: 20 } });
// { values: [5, 30] } WOULD match! (5 < 20, 30 > 10, different elements)

Combining $all and $elemMatch

// Find docs where:
// - one element satisfies { value: { $gt: 90 }, grade: 'A' }
// - AND another element satisfies { value: { $lt: 70 }, grade: 'D' }
db.results.find({
  scores: {
    $all: [
      { $elemMatch: { value: { $gt: 90 }, grade: 'A' } },
      { $elemMatch: { value: { $lt: 70 }, grade: 'D' } }
    ]
  }
});

Arrays and Index Behaviour

// Index on tags field becomes multikey automatically
db.products.createIndex({ tags: 1 });

// These queries all use the multikey index efficiently:
db.products.find({ tags: 'electronics' });
db.products.find({ tags: { $all: ['electronics', 'portable'] } });
db.products.find({ tags: { $size: 3 } });
// Note: $size cannot use the index for size filtering
// (it still needs to check document-level array length)

Using explain() With Array Queries

// Check how array queries use indexes
db.products.find({
  tags: { $all: ['electronics', 'portable'] }
}).explain('executionStats');

// Look for:
// stage: 'IXSCAN' - index is being used
// totalKeysExamined vs nReturned ratio

Quick Check

Lesson Recap