CODEWITHSUNDEEP
mongodbmongoose
finspin
finspin

Reputation: 4061

Reference field within same schema

Is it possible to reference field within same schema? See my example below. Or am I going about this wrong way?

var UserSchema = new mongoose.Schema ({
    username: String,
    password: String,
    email: String,
    foods: [{
      name: String,
      category: String,
      ingredients: // how to reference values in the ingredients array?
    }], 
    ingredients: [{
      name: String,
      category: String
    }]  
});

Upvotes: 2

Views: 1729

Answers (1)

prototype
prototype

Reputation: 7970

Short answer

This is a core MongoDB design decision: MongoDB relationships: embed or reference?

Storing references to objects, rather than independent copies of them, as you would do in a relational database is possible in MongoDB and often done, it just results in more and more complex queries when you need to look them up.

Long answer

If the goal is just to keep the definitions of ingredient schemas consistent, you can define a schema and use it twice. The ingredients will be stored as independent copies, e.g.

[{  username: 'bob', 
    ingredients: [  { name: 'Carrot', category: 'Vegetable' } , ...],
    foods:  [ { name: 'Salad', category: 'Lunch', ingredients: [ { name: 'Carrot', category: 'Vegetable'}, ...]}]
}, ...]


var IngredientSchema = new mongoose.Schema({
  name: String,
  category: String,
});


var UserSchema = new mongoose.Schema ({
    username: String,
    password: String,
    email: String,
    foods: [{
      name: String,
      category: String,
      ingredients: [IngredientSchema] // brackets indicates it's an array, 
    }], 
    ingredients: [IngredientSchema]  
});

Alternatively you can reference ingredients by objectId:

var UserSchema = new mongoose.Schema ({
     username: String,
     password: String,
    email: String,
    foods: [{
      name: String,
      category: String,
      ingredients: [mongoose.Schema.Types.ObjectId] // IDs reference individual ingredients, 
    }], 
    ingredients: [IngredientSchema]  
});

By defining IngredientSchema explicitly, each ingredient object gets its own ObjectId when it is declared. The upside to storing IDs of ingredients (rather than copies of ingredient objects) is more concise and consistent storage. The downside is there will be many more and more complex queries.

[{  username: 'bob', 
    ingredients: [  { _id: ObjectId('a298d9ef898afc98ddf'), name: 'Carrot', category: 'Vegetable' } , ...],
    foods:  [ { name: 'Salad', category: 'Lunch', ingredients: [ {$oid: 'a298d9ef898afc98ddf'}, ]}]
}, ...]

A better approach if you want to store references to Ingredients, may be to store Ingredients as its own first class collection. You'll still have many separate queries when you want to look up foods by ingredient, or ingredients by food, but the queries will be simpler.

var UserSchema = new mongoose.Schema ({
     username: String,
     password: String,
     email: String,
     foods: [{
      name: String,
      category: String,
      ingredients: [mongoose.Schema.Types.ObjectId] // IDs reference individual ingredients, 
    }], 
    ingredients: [mongoose.Schema.Types.ObjectId]  
});

if the goal is store normalized references to ingredients and search foods based on them, to quote another [SO post][1], "this is one of those cases where relational databases really shine"

See this SO post for querying subdocuments by Id: Reading categories and number of articles in a single query

As one respondent notes, "this is one of those cases where relational databases really shine"

Upvotes: 5

Related Questions