I'm just learning NoSQL, specifically MongoDB, and more specifically mongoose under Node; but this a somewhat agnostic design question.
What I'm seeing in various tutorials is a data design that has a two-way linkage between the child and parent, and the parent stores a collection of the children as an ObjectId array. Mongoose can then pull in the actual child objects with populate(). For example:
var PostSchema = new mongoose.Schema({
title: String,
comments: [{type: mongoose.Schema.Types.ObjectId, ref: 'Comment'}]
});
var CommentSchema = new mongoose.Schema({
comment: String,
post: {type: mongoose.Schema.Types.ObjectId, ref: 'Post'}
});
To me this seems to create the following problems:
1) Inserting a new comment now also requires an additional update to the Post record to add the comment id to the comments collection. Same is true for deleting a comment.
2) There is no referential integrity, the burden is on the application itself to ensure that no comments get orphaned and no posts contain invalid comment ids.
3) The populate() method is part of mongoose, not MongoDB, so if I need to access this data with something else, how do I get the child objects out?
I always (perhaps mis-)understood the benefit of NoSQL was that you could just store a whole object graph as one entity. So without looking at these tutorials, I would have naively just stored the "comments" as the full objects along with the post, and used a projection to avoid loading them when I didn't need them. Now having played with it, I don't understand why you wouldn't want to do it that way. I ask my fellow StackOverflowians for edification.
Related
I am using node.js, express and mongodb with mongoose to build out a ReSTful api. I have 2 questions regarding ReSTful best practice in conjunction with mongodb:
I have 2 collections: Chapters and Pages. The Chapters collection contains an embedded array of section documents. The (simplified) schema is as follows:
var sectionSchema = new Schema({
name: { type: String },
pages: { type: [Schema.Types.ObjectId], ref: 'Page' }
});
var chapterSchema = new Schema({
name: { type: String },
sections: [sectionSchema]
});
The contents of each section are irrelevant for now. My question is, would it make sense in my scenario to create a controller or group of routes for getting/updating an individual section element. My intuition is that I would be breaking some kind of ReSTful api best practice,
but perhaps not. Data access in my case would frequently need to get and update individual section elements from the sections array in the chapters collection.
Following on from my first question, as mentioned above, I have a 'pages' collection. If I build out routes for sections I want to make use of mongooses pseudo joins (or perhaps mongos $lookup) to return a single section element with the pages referenced its pages array. Would it make my api somehow less ReSTful considering I am accessing multiple collections. For reference the pages schema is as follows:
var pageSchema = new Schema({
chapterId: { type: Schema.Types.ObjectId },
name: { type: String },
text: { type: String }
});
Of I can accomplish all this with two controllers (Chapters and Pages) and no joins and simply fetch the referenced resources with multiple calls from the client side, but that requires more on the part of the api consumer, more requests over the wire and possibly more database hits.
In case you're wondering why I have a chapterId in each page document it's because a page belongs to a chapter and is unassigned before it is shoved somewhere into a section's array of pages. It's also a quick and easy way to get all the pages belonging to a chapter without having to query 2 collections. Feel free to comment on this aspect of my design too. Pages also require their own collection because 1. individual pages are accessed frequently and 2. pages could potentially get rather large and cumbersome.
Mostly I am using this project as an introduction into the node.js/mongodb world and web programming in general. Thanks in advance!
In below example, I want to retrieve post document filled with corresponding comments.
Do I need to hold references to comments in post as an array? Holding array with reference to comments would mean that the post document would be updated quite regularly whenever a new document is updated.
var Post = new schema({
content:String,
author:{ type: Schema.ObjectId, ref: 'User' },
createdOn:Date
});
var Comment = new Schema({
post : { type: Schema.ObjectId, ref: 'Post' },
commentText : String,
author: { type: Schema.ObjectId, ref: 'User' },
createdOn:Date
});
mongoose.model('Post',Post);
mongoose.model('Comment',Comment);
If I hold references of Comment._Id in Post as an array, then in mongoose I can populate as below.
Post.findById(postid).populate('Comments').exec( callback);
But I do not want to update post document whenever a new a comment is created as you need to push the comment id into post document. Comment has reference to Post which it belongs, so technically speaking, it is possible to retrieve comments belonging to a particular post, but if you want to retrieve or send single json document is it possible without having array containing references to comments in post document?
As always with data modelling there are just multiple ways to do things with advantages/disadvantages. Often more than one way is good enough for your app.
The question you are asking is a typical 1:n relationship, so you may:
store backrefs from the children to the parent
store an array of refs on the parent to the children
store two-way referencing by doing 1. and 2.
store the comments directly inside the post object as an array of sub-documents (comment-objects) inside the post-document.
Each of these is correct and works. Which one is the best really depends on your usage - your app. Examples:
If you have lots of concurrent creates of comments for one post, then 1. is probably a good choice, because you don't need to concurrently update the post object. But you will always need two queries to display a Post with its comments.
If you are never displaying a comment without its post, and if one comment always belongs to exactly one post, 4. may be a good choice - probably the typical choice with mongodb (a no-sql choice). -> Only one query to display a post with comments.
If you have single posts with lots of comments and it is important for your performance to be able to load only a subset of comments, 4. is a bad choice.
is probably best if you need all flexibilty, whenever you cannot predict the usage and performance is not an issue.
further info here:
http://docs.mongodb.org/manual/core/data-model-design/
I'm going nuts on a query to find a match based on referenced document properties.
I've defined my schema like this:
mongoose.model('Route', new mongoose.Schema({
user: {
type: mongoose.Schema.Types.ObjectId,
ref: 'User'
}
}));
mongoose.model('Match', new mongoose.Schema({
route: {
type: mongoose.Schema.Types.ObjectId,
ref: 'Route'
}
}));
So when I'm searching for a route from a specific user in the Match model, I'd do something like (also tried without the '_id' property):
match.find({'route.user._id': '53a821577a24cbb86cd290d0'}, function(err, docs){});
But unfortunately it doesn't give me any results. I've also tried to populate the model:
match.find({'route.user._id': '53a821577a24cbb86cd290d0'}).populate('route').exec(function(err, docs){});
But this doesn't make a difference. The solutions I'm aware of (but don't think they're the neatest):
Querying all the results and iterate through them, filtering by code
Saving the nested documents as an array (so not a reference) inside the route model
Anyone suggestions? Many thanks in advance!
Related questions (but not a working solution offered):
Mongodb/Mongoose in Node.js. Finding by id of the nested document
Use mongoose to find by a nested documents properties
I'm going nuts on a query to find a match based on nested document properties
You don't have nested documents. You have references, which are just IDs that point to documents that reside in other collections. This is your basic disconnect. If you really had nested documents, your query would match.
You are encountering the "mongodb does not do joins" situation. Each MongoDB query can search the documents within one and only one collection. Your "match" model points to a route, and the route points to a user, but the match does not directly know about the user, so your schema does not support the query you want to do. You can search the "routes" collection first and use the result of that query to find the corresponding "match" document, or you can de-normalize your schema and store both the routeId and userId directly on the match document, in which case you could then use a single query.
Based on your question title, it seems like you want nested documents but you are defining them in mongoose as references instead of real nested schemas. Use full nested schemas and fix your data, then your queries should start matching.
I'm using mongoose with Node.js for an application. I have a Document class, which has a Review subdocument. I also have a User class.
I want the user to be able to see all the reviews they've done, while I also want the Document to be able to easily get all of its reviews. Searching through all the documents and all their reviews to find ones matching a user seems horribly ineffecient. So, how do I allow the Review to be owned by both a Document and a User?
If this is impossible, how else can I efficiently have two documents know about one subdocument.
If you don't want to deal with consistency issues I don't think there's any way except for normalization to assign two parents for a document. Your issue is a common one for social networks, when developers have to deal with friends, followers, etc. Usually the best solution depends on what queries you are gonna run, what data is volatile and what is not and how many children a document might have. Usually it turns out to be a balance between embedding and referencing. Here's what I would do if I were you:
Let's assume Documents usually have 0-5 Reviews. Which is a few, so we might consider embed Reviews into Documents. Also we would often need to display reviews every time a Document is queried, this is one more reason for embedding. Now we need a way to query all reviews by a User efficiently. Assume we don't run this query as often as the first one but still it is important. Let's also assume that when we query for User's Reviews we just want to display Review titles as links to Review page or even Document page as probably it's hard to read a review without seeing the actual Document. So the best way here would be to store { document_id, review_id, reviewTitle }. ReviewTitle should not be volatile in this case. So now when you have a User object, you can easily query for reviews. Using document_id you will filter out most documents and it will be super fast. Then you can get required Reviews either on the client side or by using MapReduce to turn Reviews into separate list of documents.
This example contains many assumption so it might not be exactly what you need by my goal was to show you the most important things to consider while designing your collections and the logic you should follow. So just to sum up, consider QUERIES, HOW VOLATILE SOME DATA IS and HOW MANY CHILDREN A DOCUMENT IS GONNA HAVE, and find a balance between embeding and referencing
Hope it helps!
This is an old question, but here is a solution that, I think, works well:
var mongoose = require('mongoose'),
Schema = mongoose.Schema;
var DocumentSchema = new Schema({
title: String,
...
});
mongoose.model('Document', DocumentSchema);
var UserSchema = new Schema({
name: String,
...
});
mongoose.model('User', UserSchema);
var ReviewSchema = new Schema({
created: {
type: Date,
default: Date.now
},
document: {
type: Schema.ObjectId,
ref: 'Document'
},
reviewer: {
type: Schema.ObjectId,
ref: 'User'
},
title: String,
body: String
});
Then, you could efficiently query the Reviews to get all reviews for a User, or for a Document.
Hope this helps someone.
I'm new to mongodb and nosql databases. I would really appreciate some input/help with my schema design so I don't shoot myself in the foot.
Data: I need to model Quotes. A Quote contains many Ttems. Each Item contains many Orders. Each Order is tied to a specific fiscal quarter. Ex. I have a Quote containing an Item which has Orders in Q3-14, Q4-14, Q1-15. Orders only go max 12 quarters (3 years) into the future. Specifically, I'm having trouble with modelling the Order-quarter binding. I'm trying to denormalize the data and embed Quote <- Items <- Orders for performance.
Attempts/Ideas:
Have an Order schema containing year and qNum fields. Embed an array of Orders in every Item. Could also create virtual qKey field for setting/getting via string like Q1-14
Create a hash that embeds a Orders into an Item using keys like Q1-14. This would be nice, but isn't supported natively in Mongoose.
Store the current (base) quarter in each Quote, and have each Item contain an array of Orders, but have them indexed by #quarters offset from the base quarter. I.e. if It's currently Q1-14, and an order comes in for Q4-14, store it in array position 2.
Am I totally off the marker? Any advice is appreciated as I struggle to use Mongo effectively. Thank you
Disclaimer: I've embarked on this simply as a challenge to myself. See the <rant> below for an explanation as to why I disagree with your approach.
First step to getting a solid grasp on No-SQL is throwing out terms like "denormalize" – they simply do not apply in a document based data store. Another important concept to understand is there are no JOINS in MongoDB, so you have to change the way you think about your data completely to adjust.
The best way to solve your problem with mongoose is to setup collections for Quotes and Items separately. Then we can set up references between these collections to "link" the documents together.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var quoteSchema = new Schema({
items: [{ type: Schema.Types.ObjectId, ref: 'Item' }]
});
var itemSchema = new Schema({});
That handles your Quotes -> Items "relationship". To get the Orders setup, you could use an array of embedded documents like you've indicated, but if you ever decided to start querying/indexing Orders, you'd be up a certain creek without a paddle. Again, we can solve this with references:
var itemSchema = new Schema({
orders: [{ type: Schema.Types.ObjectId, ref: 'Order' }]
});
var orderSchema = new Schema({
quarter: String
});
Now you can use population to get what you need:
Item
.findById(id)
.populate({
path: 'orders',
match: { quarter: 'Q1-14' }
})
.exec(function (err, item) {
console.log(item.orders); // logs an array of orders from Q1-14
});
Trouble with references is that you are actually hitting the DB with a read instruction twice, once to find the parent document, and then once to populate its references.
You can read more about refs and population here: http://mongoosejs.com/docs/populate.html
<rant>
I could go on for hours why you should stick to an RDBMS for this kind of data. Especially when the defense for the choice is a lack of an ORM and Mongo being "all the rage." Engineers pick the best tech for the solution, not because a certain tech is trending. Its the difference between weekend hackery and creating Enterprise level products. Don't get me wrong, this is not to trash No-SQL – the largest codebase I maintain is built on NodeJS and MongoDB. However, I chose those technologies because they were the right technologies for my document based problem. If my data had been a relational ordering system like yours, I'd ditch Mongo in a heartbeat.
</rant>