MongoDB Discriminators: A Simple Way to Handle Polymorphism

General
1

If you’ve ever worked with a relational database, you’re familiar with the concept of inheritance, where a child table can inherit properties from a parent table. In a NoSQL database like MongoDB, there isn’t a direct equivalent, but we can achieve a similar effect using discriminators.

What is a Discriminator?

A discriminator is a special field in a MongoDB document that indicates its specific type or subtype. It allows you to store documents of different schemas within a single collection while still being able to distinguish between them. This is particularly useful for modeling polymorphism, a concept where objects of different classes can be treated as objects of a common superclass.

A classic example is an Animal collection. You might have Dog and Cat documents, both of which are types of Animal. Instead of having separate dogs and cats collections, you can store them all in one animals collection. The discriminator field, say type, would have values like dog or cat, allowing you to know the specific schema for each document.

Example with a discriminator:

By adding a type discriminator field, your documents become much more organized.

Dog Document:

JSON

{
  "_id": ObjectId("..."),
  "name": "Fido",
  "type": "dog",
  "breed": "Golden Retriever"
}

Cat Document:

JSON

{
  "_id": ObjectId("..."),
  "name": "Whiskers",
  "type": "cat",
  "color": "black"
}

Mongoose and Discriminators

While discriminators are a MongoDB concept, they are most commonly implemented and used through Object Data Modeling (ODM) libraries like Mongoose in Node.js.

Mongoose provides a simple API for creating discriminators. You define a base schema (e.g., AnimalSchema) and then create child schemas that “discriminate” from it. This allows Mongoose to automatically handle the correct schema validation, type casting, and query behavior based on the value of the discriminator field.

Here’s how it would look in Mongoose:

JavaScript

// Base Schema
const animalSchema = new Schema({
  name: String,
});

// Create the base model
const Animal = mongoose.model('Animal', animalSchema);

// Create the dog discriminator model
const Dog = Animal.discriminator('Dog', new Schema({
  breed: String,
}));

// Create the cat discriminator model
const Cat = Animal.discriminator('Cat', new Schema({
  color: String,
}));

This is a powerful way to leverage the flexibility of MongoDB’s schemaless nature while still providing the structure and validation that applications often require. It makes your code more readable, maintainable, and scalable.

1 Like