요소 연산자와 유형 검사

MongoDB's flexible schema means some documents in a collection may have fields that others lack. A user document might have an optional phoneNumber field—some users provided it, others did not. In SQL, you would handle this with a NULL value in every row. In MongoDB, the field simply does not exist in some documents.

This difference has important implications for querying. MongoDB's element operators—primarily $exists and $type—let you query based on the presence or type of a field, rather than its value.

$exists: true matches documents that have the specified field (regardless of its value, even if the value is null). $exists: false matches documents where the field is completely absent.

This distinction is subtle but important: a document with { phone: null } does match { phone: { $exists: true } } because the field exists—it is just null. Only a document with no phone field at all matches { phone: { $exists: false } }.

MongoDB's equality filter with null has a dual behavior that often surprises beginners: { phone: null } matches documents where phone is explicitly null AND documents where phone does not exist at all. This is because MongoDB considers an absent field to be implicitly null for equality comparisons.

If you want to distinguish between 'field is null' and 'field is missing', combine $exists with $eq: null. For most practical purposes, both cases mean 'no phone number provided' and you can treat them the same way.

MongoDB is schema-flexible, which means a field like price might be a Number in most documents but accidentally stored as a String in some legacy records. The $type operator lets you filter documents based on the BSON type of a field's value.

You can specify types by name (e.g., 'string', 'int', 'date') or by BSON type number (e.g., 2 for String, 16 for Int32). Using type names is more readable and preferred.

The most commonly used BSON type names for $type queries are:

• 'double' — 64-bit floating point number (JS default number)
• 'string' — UTF-8 string
• 'object' — embedded document (sub-object)
• 'array' — array
• 'binData' — binary data
• 'objectId' — ObjectId
• 'bool' — boolean
• 'date' — Date
• 'null' — null value
• 'int' — 32-bit integer
• 'long' — 64-bit integer
• 'decimal' — Decimal128

A useful shortcut is the 'number' type alias, which matches any numeric BSON type: double, int, long, and decimal. This is equivalent to writing an array of all four numeric type names but much cleaner.

Use 'number' when you want to find all documents where a field is any kind of number, regardless of the specific precision. This is particularly useful for data quality checks where you want to identify fields that should be numeric but were accidentally stored as strings.

Schema migrations in MongoDB often involve adding new required fields to existing documents. $exists helps you find the documents that still need to be updated—or that have already been migrated.

A typical migration flow: first use { newField: { $exists: false } } to find all legacy documents, then add the new field with a default value. Check progress by counting how many documents still have $exists: false. This rolling migration approach works without downtime because MongoDB's flexible schema allows old and new document shapes to coexist temporarily.

You can combine $exists and $type in one query to find documents where a field exists AND has a specific type. This is useful for data quality audits where you want to identify documents with the field set to the wrong type versus documents where the field is simply absent.

For example, in a collection where age should be a number, you might want to separately count: (1) documents missing the age field entirely, (2) documents where age is a string (data entry error), and (3) documents where age is a valid number.

The $expr operator lets you use aggregation expressions inside a regular find() filter. This unlocks cross-field comparisons—something that is not possible with standard query operators.

For example: 'find orders where the discount is greater than 50% of the original price' requires comparing discount to a computed fraction of originalPrice—two fields in the same document. $expr enables these relationships using expression operators like $gt, $multiply, and $divide.

Queries using $exists have mixed index support. An index on a field does not help with { field: { $exists: false } }—if the field is absent, it is not in the index—so MongoDB must scan every document. However, { field: { $exists: true } } can use a sparse index: a sparse index only stores entries for documents that have the indexed field, enabling fast lookups of existing documents.

Use db.collection.createIndex({ field: 1 }, { sparse: true }) to create a sparse index when you frequently query for documents that have an optional field.

A practical data quality audit workflow using and : first identify all distinct field patterns in your collection to spot inconsistencies, then categorize documents by their field types, and finally write targeted updateMany calls to normalize the data.

MongoDB's aggregation pipeline makes auditing easy: by of a field to count how many documents have each type. This gives you a clear picture of data quality issues before you start fixing them.

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

In this lesson you learned: $exists queries for the presence or absence of a field—a missing field and a null field are different and can be distinguished by combining $exists: true with $ne: null, $type filters by BSON type name (string, number, date, array, etc.) and is essential for data quality audits in schema-flexible collections, and sparse indexes efficiently support $exists: true queries on optional fields by only indexing documents that have the field. Next up we explore regex queries and pattern matching for flexible text searches.